Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacenc.c @ a9f8587e

History | View | Annotate | Download (39.5 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 "bitstream.h"
27
#include "dsputil.h"
28
#include "golomb.h"
29
#include "lpc.h"
30

    
31
#define FLAC_MAX_CH  8
32
#define FLAC_MIN_BLOCKSIZE  16
33
#define FLAC_MAX_BLOCKSIZE  65535
34

    
35
#define FLAC_SUBFRAME_CONSTANT  0
36
#define FLAC_SUBFRAME_VERBATIM  1
37
#define FLAC_SUBFRAME_FIXED     8
38
#define FLAC_SUBFRAME_LPC      32
39

    
40
#define FLAC_CHMODE_NOT_STEREO      0
41
#define FLAC_CHMODE_LEFT_RIGHT      1
42
#define FLAC_CHMODE_LEFT_SIDE       8
43
#define FLAC_CHMODE_RIGHT_SIDE      9
44
#define FLAC_CHMODE_MID_SIDE       10
45

    
46
#define FLAC_STREAMINFO_SIZE  34
47

    
48
#define MAX_FIXED_ORDER     4
49
#define MAX_PARTITION_ORDER 8
50
#define MAX_PARTITIONS     (1 << MAX_PARTITION_ORDER)
51
#define MAX_LPC_PRECISION  15
52
#define MAX_LPC_SHIFT      15
53
#define MAX_RICE_PARAM     14
54

    
55
typedef struct CompressionOptions {
56
    int compression_level;
57
    int block_time_ms;
58
    int use_lpc;
59
    int lpc_coeff_precision;
60
    int min_prediction_order;
61
    int max_prediction_order;
62
    int prediction_order_method;
63
    int min_partition_order;
64
    int max_partition_order;
65
} CompressionOptions;
66

    
67
typedef struct RiceContext {
68
    int porder;
69
    int params[MAX_PARTITIONS];
70
} RiceContext;
71

    
72
typedef struct FlacSubframe {
73
    int type;
74
    int type_code;
75
    int obits;
76
    int order;
77
    int32_t coefs[MAX_LPC_ORDER];
78
    int shift;
79
    RiceContext rc;
80
    int32_t samples[FLAC_MAX_BLOCKSIZE];
81
    int32_t residual[FLAC_MAX_BLOCKSIZE+1];
82
} FlacSubframe;
83

    
84
typedef struct FlacFrame {
85
    FlacSubframe subframes[FLAC_MAX_CH];
86
    int blocksize;
87
    int bs_code[2];
88
    uint8_t crc8;
89
    int ch_mode;
90
} FlacFrame;
91

    
92
typedef struct FlacEncodeContext {
93
    PutBitContext pb;
94
    int channels;
95
    int ch_code;
96
    int samplerate;
97
    int sr_code[2];
98
    int max_framesize;
99
    uint32_t frame_count;
100
    uint64_t sample_count;
101
    uint8_t md5sum[16];
102
    FlacFrame frame;
103
    CompressionOptions options;
104
    AVCodecContext *avctx;
105
    DSPContext dsp;
106
    struct AVMD5 *md5ctx;
107
} FlacEncodeContext;
108

    
109
static const int flac_samplerates[16] = {
110
    0, 0, 0, 0,
111
    8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
112
    0, 0, 0, 0
113
};
114

    
115
static const int flac_blocksizes[16] = {
116
    0,
117
    192,
118
    576, 1152, 2304, 4608,
119
    0, 0,
120
    256, 512, 1024, 2048, 4096, 8192, 16384, 32768
121
};
122

    
123
/**
124
 * Writes streaminfo metadata block to byte array
125
 */
126
static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
127
{
128
    PutBitContext pb;
129

    
130
    memset(header, 0, FLAC_STREAMINFO_SIZE);
131
    init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
132

    
133
    /* streaminfo metadata block */
134
    put_bits(&pb, 16, s->avctx->frame_size);
135
    put_bits(&pb, 16, s->avctx->frame_size);
136
    put_bits(&pb, 24, 0);
137
    put_bits(&pb, 24, s->max_framesize);
138
    put_bits(&pb, 20, s->samplerate);
139
    put_bits(&pb, 3, s->channels-1);
140
    put_bits(&pb, 5, 15);       /* bits per sample - 1 */
141
    /* write 36-bit sample count in 2 put_bits() calls */
142
    put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
143
    put_bits(&pb, 12,  s->sample_count & 0x000000FFFLL);
144
    flush_put_bits(&pb);
145
    memcpy(&header[18], s->md5sum, 16);
146
}
147

    
148
/**
149
 * Sets blocksize based on samplerate
150
 * Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
151
 */
152
static int select_blocksize(int samplerate, int block_time_ms)
153
{
154
    int i;
155
    int target;
156
    int blocksize;
157

    
158
    assert(samplerate > 0);
159
    blocksize = flac_blocksizes[1];
160
    target = (samplerate * block_time_ms) / 1000;
161
    for(i=0; i<16; i++) {
162
        if(target >= flac_blocksizes[i] && flac_blocksizes[i] > blocksize) {
163
            blocksize = flac_blocksizes[i];
164
        }
165
    }
166
    return blocksize;
167
}
168

    
169
static av_cold int flac_encode_init(AVCodecContext *avctx)
170
{
171
    int freq = avctx->sample_rate;
172
    int channels = avctx->channels;
173
    FlacEncodeContext *s = avctx->priv_data;
174
    int i, level;
175
    uint8_t *streaminfo;
176

    
177
    s->avctx = avctx;
178

    
179
    dsputil_init(&s->dsp, avctx);
180

    
181
    if(avctx->sample_fmt != SAMPLE_FMT_S16) {
182
        return -1;
183
    }
184

    
185
    if(channels < 1 || channels > FLAC_MAX_CH) {
186
        return -1;
187
    }
188
    s->channels = channels;
189
    s->ch_code = s->channels-1;
190

    
191
    /* find samplerate in table */
192
    if(freq < 1)
193
        return -1;
194
    for(i=4; i<12; i++) {
195
        if(freq == flac_samplerates[i]) {
196
            s->samplerate = flac_samplerates[i];
197
            s->sr_code[0] = i;
198
            s->sr_code[1] = 0;
199
            break;
200
        }
201
    }
202
    /* if not in table, samplerate is non-standard */
203
    if(i == 12) {
204
        if(freq % 1000 == 0 && freq < 255000) {
205
            s->sr_code[0] = 12;
206
            s->sr_code[1] = freq / 1000;
207
        } else if(freq % 10 == 0 && freq < 655350) {
208
            s->sr_code[0] = 14;
209
            s->sr_code[1] = freq / 10;
210
        } else if(freq < 65535) {
211
            s->sr_code[0] = 13;
212
            s->sr_code[1] = freq;
213
        } else {
214
            return -1;
215
        }
216
        s->samplerate = freq;
217
    }
218

    
219
    /* set compression option defaults based on avctx->compression_level */
220
    if(avctx->compression_level < 0) {
221
        s->options.compression_level = 5;
222
    } else {
223
        s->options.compression_level = avctx->compression_level;
224
    }
225
    av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", s->options.compression_level);
226

    
227
    level= s->options.compression_level;
228
    if(level > 12) {
229
        av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
230
               s->options.compression_level);
231
        return -1;
232
    }
233

    
234
    s->options.block_time_ms       = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
235
    s->options.use_lpc             = ((int[]){  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
236
    s->options.min_prediction_order= ((int[]){  2,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
237
    s->options.max_prediction_order= ((int[]){  3,  4,  4,  6,  8,  8,  8,  8, 12, 12, 12, 32, 32})[level];
238
    s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
239
                                                   ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
240
                                                   ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG,    ORDER_METHOD_4LEVEL,
241
                                                   ORDER_METHOD_LOG,    ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
242
                                                   ORDER_METHOD_SEARCH})[level];
243
    s->options.min_partition_order = ((int[]){  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0})[level];
244
    s->options.max_partition_order = ((int[]){  2,  2,  3,  3,  3,  8,  8,  8,  8,  8,  8,  8,  8})[level];
245

    
246
    /* set compression option overrides from AVCodecContext */
247
    if(avctx->use_lpc >= 0) {
248
        s->options.use_lpc = av_clip(avctx->use_lpc, 0, 11);
249
    }
250
    if(s->options.use_lpc == 1)
251
        av_log(avctx, AV_LOG_DEBUG, " use lpc: Levinson-Durbin recursion with Welch window\n");
252
    else if(s->options.use_lpc > 1)
253
        av_log(avctx, AV_LOG_DEBUG, " use lpc: Cholesky factorization\n");
254

    
255
    if(avctx->min_prediction_order >= 0) {
256
        if(s->options.use_lpc) {
257
            if(avctx->min_prediction_order < MIN_LPC_ORDER ||
258
                    avctx->min_prediction_order > MAX_LPC_ORDER) {
259
                av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
260
                       avctx->min_prediction_order);
261
                return -1;
262
            }
263
        } else {
264
            if(avctx->min_prediction_order > MAX_FIXED_ORDER) {
265
                av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
266
                       avctx->min_prediction_order);
267
                return -1;
268
            }
269
        }
270
        s->options.min_prediction_order = avctx->min_prediction_order;
271
    }
272
    if(avctx->max_prediction_order >= 0) {
273
        if(s->options.use_lpc) {
274
            if(avctx->max_prediction_order < MIN_LPC_ORDER ||
275
                    avctx->max_prediction_order > MAX_LPC_ORDER) {
276
                av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
277
                       avctx->max_prediction_order);
278
                return -1;
279
            }
280
        } else {
281
            if(avctx->max_prediction_order > MAX_FIXED_ORDER) {
282
                av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
283
                       avctx->max_prediction_order);
284
                return -1;
285
            }
286
        }
287
        s->options.max_prediction_order = avctx->max_prediction_order;
288
    }
289
    if(s->options.max_prediction_order < s->options.min_prediction_order) {
290
        av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
291
               s->options.min_prediction_order, s->options.max_prediction_order);
292
        return -1;
293
    }
294
    av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",
295
           s->options.min_prediction_order, s->options.max_prediction_order);
296

    
297
    if(avctx->prediction_order_method >= 0) {
298
        if(avctx->prediction_order_method > ORDER_METHOD_LOG) {
299
            av_log(avctx, AV_LOG_ERROR, "invalid prediction order method: %d\n",
300
                   avctx->prediction_order_method);
301
            return -1;
302
        }
303
        s->options.prediction_order_method = avctx->prediction_order_method;
304
    }
305
    switch(s->options.prediction_order_method) {
306
        case ORDER_METHOD_EST:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
307
                                         "estimate"); break;
308
        case ORDER_METHOD_2LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
309
                                         "2-level"); break;
310
        case ORDER_METHOD_4LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
311
                                         "4-level"); break;
312
        case ORDER_METHOD_8LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
313
                                         "8-level"); break;
314
        case ORDER_METHOD_SEARCH: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
315
                                         "full search"); break;
316
        case ORDER_METHOD_LOG:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
317
                                         "log search"); break;
318
    }
319

    
320
    if(avctx->min_partition_order >= 0) {
321
        if(avctx->min_partition_order > MAX_PARTITION_ORDER) {
322
            av_log(avctx, AV_LOG_ERROR, "invalid min partition order: %d\n",
323
                   avctx->min_partition_order);
324
            return -1;
325
        }
326
        s->options.min_partition_order = avctx->min_partition_order;
327
    }
328
    if(avctx->max_partition_order >= 0) {
329
        if(avctx->max_partition_order > MAX_PARTITION_ORDER) {
330
            av_log(avctx, AV_LOG_ERROR, "invalid max partition order: %d\n",
331
                   avctx->max_partition_order);
332
            return -1;
333
        }
334
        s->options.max_partition_order = avctx->max_partition_order;
335
    }
336
    if(s->options.max_partition_order < s->options.min_partition_order) {
337
        av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
338
               s->options.min_partition_order, s->options.max_partition_order);
339
        return -1;
340
    }
341
    av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",
342
           s->options.min_partition_order, s->options.max_partition_order);
343

    
344
    if(avctx->frame_size > 0) {
345
        if(avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
346
                avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
347
            av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
348
                   avctx->frame_size);
349
            return -1;
350
        }
351
    } else {
352
        s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
353
    }
354
    av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->avctx->frame_size);
355

    
356
    /* set LPC precision */
357
    if(avctx->lpc_coeff_precision > 0) {
358
        if(avctx->lpc_coeff_precision > MAX_LPC_PRECISION) {
359
            av_log(avctx, AV_LOG_ERROR, "invalid lpc coeff precision: %d\n",
360
                   avctx->lpc_coeff_precision);
361
            return -1;
362
        }
363
        s->options.lpc_coeff_precision = avctx->lpc_coeff_precision;
364
    } else {
365
        /* default LPC precision */
366
        s->options.lpc_coeff_precision = 15;
367
    }
368
    av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
369
           s->options.lpc_coeff_precision);
370

    
371
    /* set maximum encoded frame size in verbatim mode */
372
    if(s->channels == 2) {
373
        s->max_framesize = 14 + ((s->avctx->frame_size * 33 + 7) >> 3);
374
    } else {
375
        s->max_framesize = 14 + (s->avctx->frame_size * s->channels * 2);
376
    }
377

    
378
    /* initialize MD5 context */
379
    s->md5ctx = av_malloc(av_md5_size);
380
    if(!s->md5ctx)
381
        return AVERROR_NOMEM;
382
    av_md5_init(s->md5ctx);
383

    
384
    streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
385
    write_streaminfo(s, streaminfo);
386
    avctx->extradata = streaminfo;
387
    avctx->extradata_size = FLAC_STREAMINFO_SIZE;
388

    
389
    s->frame_count = 0;
390

    
391
    avctx->coded_frame = avcodec_alloc_frame();
392
    avctx->coded_frame->key_frame = 1;
393

    
394
    return 0;
395
}
396

    
397
static void init_frame(FlacEncodeContext *s)
398
{
399
    int i, ch;
400
    FlacFrame *frame;
401

    
402
    frame = &s->frame;
403

    
404
    for(i=0; i<16; i++) {
405
        if(s->avctx->frame_size == flac_blocksizes[i]) {
406
            frame->blocksize = flac_blocksizes[i];
407
            frame->bs_code[0] = i;
408
            frame->bs_code[1] = 0;
409
            break;
410
        }
411
    }
412
    if(i == 16) {
413
        frame->blocksize = s->avctx->frame_size;
414
        if(frame->blocksize <= 256) {
415
            frame->bs_code[0] = 6;
416
            frame->bs_code[1] = frame->blocksize-1;
417
        } else {
418
            frame->bs_code[0] = 7;
419
            frame->bs_code[1] = frame->blocksize-1;
420
        }
421
    }
422

    
423
    for(ch=0; ch<s->channels; ch++) {
424
        frame->subframes[ch].obits = 16;
425
    }
426
}
427

    
428
/**
429
 * Copy channel-interleaved input samples into separate subframes
430
 */
431
static void copy_samples(FlacEncodeContext *s, int16_t *samples)
432
{
433
    int i, j, ch;
434
    FlacFrame *frame;
435

    
436
    frame = &s->frame;
437
    for(i=0,j=0; i<frame->blocksize; i++) {
438
        for(ch=0; ch<s->channels; ch++,j++) {
439
            frame->subframes[ch].samples[i] = samples[j];
440
        }
441
    }
442
}
443

    
444

    
445
#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
446

    
447
/**
448
 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
449
 */
450
static int find_optimal_param(uint32_t sum, int n)
451
{
452
    int k;
453
    uint32_t sum2;
454

    
455
    if(sum <= n>>1)
456
        return 0;
457
    sum2 = sum-(n>>1);
458
    k = av_log2(n<256 ? FASTDIV(sum2,n) : sum2/n);
459
    return FFMIN(k, MAX_RICE_PARAM);
460
}
461

    
462
static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
463
                                         uint32_t *sums, int n, int pred_order)
464
{
465
    int i;
466
    int k, cnt, part;
467
    uint32_t all_bits;
468

    
469
    part = (1 << porder);
470
    all_bits = 4 * part;
471

    
472
    cnt = (n >> porder) - pred_order;
473
    for(i=0; i<part; i++) {
474
        k = find_optimal_param(sums[i], cnt);
475
        rc->params[i] = k;
476
        all_bits += rice_encode_count(sums[i], cnt, k);
477
        cnt = n >> porder;
478
    }
479

    
480
    rc->porder = porder;
481

    
482
    return all_bits;
483
}
484

    
485
static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
486
                      uint32_t sums[][MAX_PARTITIONS])
487
{
488
    int i, j;
489
    int parts;
490
    uint32_t *res, *res_end;
491

    
492
    /* sums for highest level */
493
    parts = (1 << pmax);
494
    res = &data[pred_order];
495
    res_end = &data[n >> pmax];
496
    for(i=0; i<parts; i++) {
497
        uint32_t sum = 0;
498
        while(res < res_end){
499
            sum += *(res++);
500
        }
501
        sums[pmax][i] = sum;
502
        res_end+= n >> pmax;
503
    }
504
    /* sums for lower levels */
505
    for(i=pmax-1; i>=pmin; i--) {
506
        parts = (1 << i);
507
        for(j=0; j<parts; j++) {
508
            sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
509
        }
510
    }
511
}
512

    
513
static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
514
                                 int32_t *data, int n, int pred_order)
515
{
516
    int i;
517
    uint32_t bits[MAX_PARTITION_ORDER+1];
518
    int opt_porder;
519
    RiceContext tmp_rc;
520
    uint32_t *udata;
521
    uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];
522

    
523
    assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
524
    assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
525
    assert(pmin <= pmax);
526

    
527
    udata = av_malloc(n * sizeof(uint32_t));
528
    for(i=0; i<n; i++) {
529
        udata[i] = (2*data[i]) ^ (data[i]>>31);
530
    }
531

    
532
    calc_sums(pmin, pmax, udata, n, pred_order, sums);
533

    
534
    opt_porder = pmin;
535
    bits[pmin] = UINT32_MAX;
536
    for(i=pmin; i<=pmax; i++) {
537
        bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order);
538
        if(bits[i] <= bits[opt_porder]) {
539
            opt_porder = i;
540
            *rc= tmp_rc;
541
        }
542
    }
543

    
544
    av_freep(&udata);
545
    return bits[opt_porder];
546
}
547

    
548
static int get_max_p_order(int max_porder, int n, int order)
549
{
550
    int porder = FFMIN(max_porder, av_log2(n^(n-1)));
551
    if(order > 0)
552
        porder = FFMIN(porder, av_log2(n/order));
553
    return porder;
554
}
555

    
556
static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
557
                                       int32_t *data, int n, int pred_order,
558
                                       int bps)
559
{
560
    uint32_t bits;
561
    pmin = get_max_p_order(pmin, n, pred_order);
562
    pmax = get_max_p_order(pmax, n, pred_order);
563
    bits = pred_order*bps + 6;
564
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
565
    return bits;
566
}
567

    
568
static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
569
                                     int32_t *data, int n, int pred_order,
570
                                     int bps, int precision)
571
{
572
    uint32_t bits;
573
    pmin = get_max_p_order(pmin, n, pred_order);
574
    pmax = get_max_p_order(pmax, n, pred_order);
575
    bits = pred_order*bps + 4 + 5 + pred_order*precision + 6;
576
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
577
    return bits;
578
}
579

    
580
/**
581
 * Apply Welch window function to audio block
582
 */
583
static void apply_welch_window(const int32_t *data, int len, double *w_data)
584
{
585
    int i, n2;
586
    double w;
587
    double c;
588

    
589
    assert(!(len&1)); //the optimization in r11881 does not support odd len
590
                      //if someone wants odd len extend the change in r11881
591

    
592
    n2 = (len >> 1);
593
    c = 2.0 / (len - 1.0);
594

    
595
    w_data+=n2;
596
      data+=n2;
597
    for(i=0; i<n2; i++) {
598
        w = c - n2 + i;
599
        w = 1.0 - (w * w);
600
        w_data[-i-1] = data[-i-1] * w;
601
        w_data[+i  ] = data[+i  ] * w;
602
    }
603
}
604

    
605
/**
606
 * Calculates autocorrelation data from audio samples
607
 * A Welch window function is applied before calculation.
608
 */
609
void ff_flac_compute_autocorr(const int32_t *data, int len, int lag,
610
                              double *autoc)
611
{
612
    int i, j;
613
    double tmp[len + lag + 1];
614
    double *data1= tmp + lag;
615

    
616
    apply_welch_window(data, len, data1);
617

    
618
    for(j=0; j<lag; j++)
619
        data1[j-lag]= 0.0;
620
    data1[len] = 0.0;
621

    
622
    for(j=0; j<lag; j+=2){
623
        double sum0 = 1.0, sum1 = 1.0;
624
        for(i=0; i<len; i++){
625
            sum0 += data1[i] * data1[i-j];
626
            sum1 += data1[i] * data1[i-j-1];
627
        }
628
        autoc[j  ] = sum0;
629
        autoc[j+1] = sum1;
630
    }
631

    
632
    if(j==lag){
633
        double sum = 1.0;
634
        for(i=0; i<len; i+=2){
635
            sum += data1[i  ] * data1[i-j  ]
636
                 + data1[i+1] * data1[i-j+1];
637
        }
638
        autoc[j] = sum;
639
    }
640
}
641

    
642

    
643
static void encode_residual_verbatim(int32_t *res, int32_t *smp, int n)
644
{
645
    assert(n > 0);
646
    memcpy(res, smp, n * sizeof(int32_t));
647
}
648

    
649
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
650
                                  int order)
651
{
652
    int i;
653

    
654
    for(i=0; i<order; i++) {
655
        res[i] = smp[i];
656
    }
657

    
658
    if(order==0){
659
        for(i=order; i<n; i++)
660
            res[i]= smp[i];
661
    }else if(order==1){
662
        for(i=order; i<n; i++)
663
            res[i]= smp[i] - smp[i-1];
664
    }else if(order==2){
665
        int a = smp[order-1] - smp[order-2];
666
        for(i=order; i<n; i+=2) {
667
            int b = smp[i] - smp[i-1];
668
            res[i]= b - a;
669
            a = smp[i+1] - smp[i];
670
            res[i+1]= a - b;
671
        }
672
    }else if(order==3){
673
        int a = smp[order-1] - smp[order-2];
674
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
675
        for(i=order; i<n; i+=2) {
676
            int b = smp[i] - smp[i-1];
677
            int d = b - a;
678
            res[i]= d - c;
679
            a = smp[i+1] - smp[i];
680
            c = a - b;
681
            res[i+1]= c - d;
682
        }
683
    }else{
684
        int a = smp[order-1] - smp[order-2];
685
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
686
        int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
687
        for(i=order; i<n; i+=2) {
688
            int b = smp[i] - smp[i-1];
689
            int d = b - a;
690
            int f = d - c;
691
            res[i]= f - e;
692
            a = smp[i+1] - smp[i];
693
            c = a - b;
694
            e = c - d;
695
            res[i+1]= e - f;
696
        }
697
    }
698
}
699

    
700
#define LPC1(x) {\
701
    int c = coefs[(x)-1];\
702
    p0 += c*s;\
703
    s = smp[i-(x)+1];\
704
    p1 += c*s;\
705
}
706

    
707
static av_always_inline void encode_residual_lpc_unrolled(
708
    int32_t *res, const int32_t *smp, int n,
709
    int order, const int32_t *coefs, int shift, int big)
710
{
711
    int i;
712
    for(i=order; i<n; i+=2) {
713
        int s = smp[i-order];
714
        int p0 = 0, p1 = 0;
715
        if(big) {
716
            switch(order) {
717
                case 32: LPC1(32)
718
                case 31: LPC1(31)
719
                case 30: LPC1(30)
720
                case 29: LPC1(29)
721
                case 28: LPC1(28)
722
                case 27: LPC1(27)
723
                case 26: LPC1(26)
724
                case 25: LPC1(25)
725
                case 24: LPC1(24)
726
                case 23: LPC1(23)
727
                case 22: LPC1(22)
728
                case 21: LPC1(21)
729
                case 20: LPC1(20)
730
                case 19: LPC1(19)
731
                case 18: LPC1(18)
732
                case 17: LPC1(17)
733
                case 16: LPC1(16)
734
                case 15: LPC1(15)
735
                case 14: LPC1(14)
736
                case 13: LPC1(13)
737
                case 12: LPC1(12)
738
                case 11: LPC1(11)
739
                case 10: LPC1(10)
740
                case  9: LPC1( 9)
741
                         LPC1( 8)
742
                         LPC1( 7)
743
                         LPC1( 6)
744
                         LPC1( 5)
745
                         LPC1( 4)
746
                         LPC1( 3)
747
                         LPC1( 2)
748
                         LPC1( 1)
749
            }
750
        } else {
751
            switch(order) {
752
                case  8: LPC1( 8)
753
                case  7: LPC1( 7)
754
                case  6: LPC1( 6)
755
                case  5: LPC1( 5)
756
                case  4: LPC1( 4)
757
                case  3: LPC1( 3)
758
                case  2: LPC1( 2)
759
                case  1: LPC1( 1)
760
            }
761
        }
762
        res[i  ] = smp[i  ] - (p0 >> shift);
763
        res[i+1] = smp[i+1] - (p1 >> shift);
764
    }
765
}
766

    
767
static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
768
                                int order, const int32_t *coefs, int shift)
769
{
770
    int i;
771
    for(i=0; i<order; i++) {
772
        res[i] = smp[i];
773
    }
774
#ifdef CONFIG_SMALL
775
    for(i=order; i<n; i+=2) {
776
        int j;
777
        int s = smp[i];
778
        int p0 = 0, p1 = 0;
779
        for(j=0; j<order; j++) {
780
            int c = coefs[j];
781
            p1 += c*s;
782
            s = smp[i-j-1];
783
            p0 += c*s;
784
        }
785
        res[i  ] = smp[i  ] - (p0 >> shift);
786
        res[i+1] = smp[i+1] - (p1 >> shift);
787
    }
788
#else
789
    switch(order) {
790
        case  1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break;
791
        case  2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break;
792
        case  3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break;
793
        case  4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break;
794
        case  5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break;
795
        case  6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break;
796
        case  7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break;
797
        case  8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break;
798
        default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break;
799
    }
800
#endif
801
}
802

    
803
static int encode_residual(FlacEncodeContext *ctx, int ch)
804
{
805
    int i, n;
806
    int min_order, max_order, opt_order, precision, omethod;
807
    int min_porder, max_porder;
808
    FlacFrame *frame;
809
    FlacSubframe *sub;
810
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
811
    int shift[MAX_LPC_ORDER];
812
    int32_t *res, *smp;
813

    
814
    frame = &ctx->frame;
815
    sub = &frame->subframes[ch];
816
    res = sub->residual;
817
    smp = sub->samples;
818
    n = frame->blocksize;
819

    
820
    /* CONSTANT */
821
    for(i=1; i<n; i++) {
822
        if(smp[i] != smp[0]) break;
823
    }
824
    if(i == n) {
825
        sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
826
        res[0] = smp[0];
827
        return sub->obits;
828
    }
829

    
830
    /* VERBATIM */
831
    if(n < 5) {
832
        sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
833
        encode_residual_verbatim(res, smp, n);
834
        return sub->obits * n;
835
    }
836

    
837
    min_order = ctx->options.min_prediction_order;
838
    max_order = ctx->options.max_prediction_order;
839
    min_porder = ctx->options.min_partition_order;
840
    max_porder = ctx->options.max_partition_order;
841
    precision = ctx->options.lpc_coeff_precision;
842
    omethod = ctx->options.prediction_order_method;
843

    
844
    /* FIXED */
845
    if(!ctx->options.use_lpc || max_order == 0 || (n <= max_order)) {
846
        uint32_t bits[MAX_FIXED_ORDER+1];
847
        if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;
848
        opt_order = 0;
849
        bits[0] = UINT32_MAX;
850
        for(i=min_order; i<=max_order; i++) {
851
            encode_residual_fixed(res, smp, n, i);
852
            bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
853
                                             n, i, sub->obits);
854
            if(bits[i] < bits[opt_order]) {
855
                opt_order = i;
856
            }
857
        }
858
        sub->order = opt_order;
859
        sub->type = FLAC_SUBFRAME_FIXED;
860
        sub->type_code = sub->type | sub->order;
861
        if(sub->order != max_order) {
862
            encode_residual_fixed(res, smp, n, sub->order);
863
            return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
864
                                          sub->order, sub->obits);
865
        }
866
        return bits[sub->order];
867
    }
868

    
869
    /* LPC */
870
    opt_order = ff_lpc_calc_coefs(&ctx->dsp, smp, n, min_order, max_order,
871
                                  precision, coefs, shift, ctx->options.use_lpc,
872
                                  omethod, MAX_LPC_SHIFT, 0);
873

    
874
    if(omethod == ORDER_METHOD_2LEVEL ||
875
       omethod == ORDER_METHOD_4LEVEL ||
876
       omethod == ORDER_METHOD_8LEVEL) {
877
        int levels = 1 << omethod;
878
        uint32_t bits[levels];
879
        int order;
880
        int opt_index = levels-1;
881
        opt_order = max_order-1;
882
        bits[opt_index] = UINT32_MAX;
883
        for(i=levels-1; i>=0; i--) {
884
            order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
885
            if(order < 0) order = 0;
886
            encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
887
            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
888
                                           res, n, order+1, sub->obits, precision);
889
            if(bits[i] < bits[opt_index]) {
890
                opt_index = i;
891
                opt_order = order;
892
            }
893
        }
894
        opt_order++;
895
    } else if(omethod == ORDER_METHOD_SEARCH) {
896
        // brute-force optimal order search
897
        uint32_t bits[MAX_LPC_ORDER];
898
        opt_order = 0;
899
        bits[0] = UINT32_MAX;
900
        for(i=min_order-1; i<max_order; i++) {
901
            encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
902
            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
903
                                           res, n, i+1, sub->obits, precision);
904
            if(bits[i] < bits[opt_order]) {
905
                opt_order = i;
906
            }
907
        }
908
        opt_order++;
909
    } else if(omethod == ORDER_METHOD_LOG) {
910
        uint32_t bits[MAX_LPC_ORDER];
911
        int step;
912

    
913
        opt_order= min_order - 1 + (max_order-min_order)/3;
914
        memset(bits, -1, sizeof(bits));
915

    
916
        for(step=16 ;step; step>>=1){
917
            int last= opt_order;
918
            for(i=last-step; i<=last+step; i+= step){
919
                if(i<min_order-1 || i>=max_order || bits[i] < UINT32_MAX)
920
                    continue;
921
                encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
922
                bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
923
                                            res, n, i+1, sub->obits, precision);
924
                if(bits[i] < bits[opt_order])
925
                    opt_order= i;
926
            }
927
        }
928
        opt_order++;
929
    }
930

    
931
    sub->order = opt_order;
932
    sub->type = FLAC_SUBFRAME_LPC;
933
    sub->type_code = sub->type | (sub->order-1);
934
    sub->shift = shift[sub->order-1];
935
    for(i=0; i<sub->order; i++) {
936
        sub->coefs[i] = coefs[sub->order-1][i];
937
    }
938
    encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
939
    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
940
                                sub->obits, precision);
941
}
942

    
943
static int encode_residual_v(FlacEncodeContext *ctx, int ch)
944
{
945
    int i, n;
946
    FlacFrame *frame;
947
    FlacSubframe *sub;
948
    int32_t *res, *smp;
949

    
950
    frame = &ctx->frame;
951
    sub = &frame->subframes[ch];
952
    res = sub->residual;
953
    smp = sub->samples;
954
    n = frame->blocksize;
955

    
956
    /* CONSTANT */
957
    for(i=1; i<n; i++) {
958
        if(smp[i] != smp[0]) break;
959
    }
960
    if(i == n) {
961
        sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
962
        res[0] = smp[0];
963
        return sub->obits;
964
    }
965

    
966
    /* VERBATIM */
967
    sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
968
    encode_residual_verbatim(res, smp, n);
969
    return sub->obits * n;
970
}
971

    
972
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
973
{
974
    int i, best;
975
    int32_t lt, rt;
976
    uint64_t sum[4];
977
    uint64_t score[4];
978
    int k;
979

    
980
    /* calculate sum of 2nd order residual for each channel */
981
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
982
    for(i=2; i<n; i++) {
983
        lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
984
        rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
985
        sum[2] += FFABS((lt + rt) >> 1);
986
        sum[3] += FFABS(lt - rt);
987
        sum[0] += FFABS(lt);
988
        sum[1] += FFABS(rt);
989
    }
990
    /* estimate bit counts */
991
    for(i=0; i<4; i++) {
992
        k = find_optimal_param(2*sum[i], n);
993
        sum[i] = rice_encode_count(2*sum[i], n, k);
994
    }
995

    
996
    /* calculate score for each mode */
997
    score[0] = sum[0] + sum[1];
998
    score[1] = sum[0] + sum[3];
999
    score[2] = sum[1] + sum[3];
1000
    score[3] = sum[2] + sum[3];
1001

    
1002
    /* return mode with lowest score */
1003
    best = 0;
1004
    for(i=1; i<4; i++) {
1005
        if(score[i] < score[best]) {
1006
            best = i;
1007
        }
1008
    }
1009
    if(best == 0) {
1010
        return FLAC_CHMODE_LEFT_RIGHT;
1011
    } else if(best == 1) {
1012
        return FLAC_CHMODE_LEFT_SIDE;
1013
    } else if(best == 2) {
1014
        return FLAC_CHMODE_RIGHT_SIDE;
1015
    } else {
1016
        return FLAC_CHMODE_MID_SIDE;
1017
    }
1018
}
1019

    
1020
/**
1021
 * Perform stereo channel decorrelation
1022
 */
1023
static void channel_decorrelation(FlacEncodeContext *ctx)
1024
{
1025
    FlacFrame *frame;
1026
    int32_t *left, *right;
1027
    int i, n;
1028

    
1029
    frame = &ctx->frame;
1030
    n = frame->blocksize;
1031
    left  = frame->subframes[0].samples;
1032
    right = frame->subframes[1].samples;
1033

    
1034
    if(ctx->channels != 2) {
1035
        frame->ch_mode = FLAC_CHMODE_NOT_STEREO;
1036
        return;
1037
    }
1038

    
1039
    frame->ch_mode = estimate_stereo_mode(left, right, n);
1040

    
1041
    /* perform decorrelation and adjust bits-per-sample */
1042
    if(frame->ch_mode == FLAC_CHMODE_LEFT_RIGHT) {
1043
        return;
1044
    }
1045
    if(frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1046
        int32_t tmp;
1047
        for(i=0; i<n; i++) {
1048
            tmp = left[i];
1049
            left[i] = (tmp + right[i]) >> 1;
1050
            right[i] = tmp - right[i];
1051
        }
1052
        frame->subframes[1].obits++;
1053
    } else if(frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1054
        for(i=0; i<n; i++) {
1055
            right[i] = left[i] - right[i];
1056
        }
1057
        frame->subframes[1].obits++;
1058
    } else {
1059
        for(i=0; i<n; i++) {
1060
            left[i] -= right[i];
1061
        }
1062
        frame->subframes[0].obits++;
1063
    }
1064
}
1065

    
1066
static void write_utf8(PutBitContext *pb, uint32_t val)
1067
{
1068
    uint8_t tmp;
1069
    PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
1070
}
1071

    
1072
static void output_frame_header(FlacEncodeContext *s)
1073
{
1074
    FlacFrame *frame;
1075
    int crc;
1076

    
1077
    frame = &s->frame;
1078

    
1079
    put_bits(&s->pb, 16, 0xFFF8);
1080
    put_bits(&s->pb, 4, frame->bs_code[0]);
1081
    put_bits(&s->pb, 4, s->sr_code[0]);
1082
    if(frame->ch_mode == FLAC_CHMODE_NOT_STEREO) {
1083
        put_bits(&s->pb, 4, s->ch_code);
1084
    } else {
1085
        put_bits(&s->pb, 4, frame->ch_mode);
1086
    }
1087
    put_bits(&s->pb, 3, 4); /* bits-per-sample code */
1088
    put_bits(&s->pb, 1, 0);
1089
    write_utf8(&s->pb, s->frame_count);
1090
    if(frame->bs_code[0] == 6) {
1091
        put_bits(&s->pb, 8, frame->bs_code[1]);
1092
    } else if(frame->bs_code[0] == 7) {
1093
        put_bits(&s->pb, 16, frame->bs_code[1]);
1094
    }
1095
    if(s->sr_code[0] == 12) {
1096
        put_bits(&s->pb, 8, s->sr_code[1]);
1097
    } else if(s->sr_code[0] > 12) {
1098
        put_bits(&s->pb, 16, s->sr_code[1]);
1099
    }
1100
    flush_put_bits(&s->pb);
1101
    crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
1102
                 s->pb.buf, put_bits_count(&s->pb)>>3);
1103
    put_bits(&s->pb, 8, crc);
1104
}
1105

    
1106
static void output_subframe_constant(FlacEncodeContext *s, int ch)
1107
{
1108
    FlacSubframe *sub;
1109
    int32_t res;
1110

    
1111
    sub = &s->frame.subframes[ch];
1112
    res = sub->residual[0];
1113
    put_sbits(&s->pb, sub->obits, res);
1114
}
1115

    
1116
static void output_subframe_verbatim(FlacEncodeContext *s, int ch)
1117
{
1118
    int i;
1119
    FlacFrame *frame;
1120
    FlacSubframe *sub;
1121
    int32_t res;
1122

    
1123
    frame = &s->frame;
1124
    sub = &frame->subframes[ch];
1125

    
1126
    for(i=0; i<frame->blocksize; i++) {
1127
        res = sub->residual[i];
1128
        put_sbits(&s->pb, sub->obits, res);
1129
    }
1130
}
1131

    
1132
static void output_residual(FlacEncodeContext *ctx, int ch)
1133
{
1134
    int i, j, p, n, parts;
1135
    int k, porder, psize, res_cnt;
1136
    FlacFrame *frame;
1137
    FlacSubframe *sub;
1138
    int32_t *res;
1139

    
1140
    frame = &ctx->frame;
1141
    sub = &frame->subframes[ch];
1142
    res = sub->residual;
1143
    n = frame->blocksize;
1144

    
1145
    /* rice-encoded block */
1146
    put_bits(&ctx->pb, 2, 0);
1147

    
1148
    /* partition order */
1149
    porder = sub->rc.porder;
1150
    psize = n >> porder;
1151
    parts = (1 << porder);
1152
    put_bits(&ctx->pb, 4, porder);
1153
    res_cnt = psize - sub->order;
1154

    
1155
    /* residual */
1156
    j = sub->order;
1157
    for(p=0; p<parts; p++) {
1158
        k = sub->rc.params[p];
1159
        put_bits(&ctx->pb, 4, k);
1160
        if(p == 1) res_cnt = psize;
1161
        for(i=0; i<res_cnt && j<n; i++, j++) {
1162
            set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
1163
        }
1164
    }
1165
}
1166

    
1167
static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
1168
{
1169
    int i;
1170
    FlacFrame *frame;
1171
    FlacSubframe *sub;
1172

    
1173
    frame = &ctx->frame;
1174
    sub = &frame->subframes[ch];
1175

    
1176
    /* warm-up samples */
1177
    for(i=0; i<sub->order; i++) {
1178
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1179
    }
1180

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

    
1185
static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
1186
{
1187
    int i, cbits;
1188
    FlacFrame *frame;
1189
    FlacSubframe *sub;
1190

    
1191
    frame = &ctx->frame;
1192
    sub = &frame->subframes[ch];
1193

    
1194
    /* warm-up samples */
1195
    for(i=0; i<sub->order; i++) {
1196
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1197
    }
1198

    
1199
    /* LPC coefficients */
1200
    cbits = ctx->options.lpc_coeff_precision;
1201
    put_bits(&ctx->pb, 4, cbits-1);
1202
    put_sbits(&ctx->pb, 5, sub->shift);
1203
    for(i=0; i<sub->order; i++) {
1204
        put_sbits(&ctx->pb, cbits, sub->coefs[i]);
1205
    }
1206

    
1207
    /* residual */
1208
    output_residual(ctx, ch);
1209
}
1210

    
1211
static void output_subframes(FlacEncodeContext *s)
1212
{
1213
    FlacFrame *frame;
1214
    FlacSubframe *sub;
1215
    int ch;
1216

    
1217
    frame = &s->frame;
1218

    
1219
    for(ch=0; ch<s->channels; ch++) {
1220
        sub = &frame->subframes[ch];
1221

    
1222
        /* subframe header */
1223
        put_bits(&s->pb, 1, 0);
1224
        put_bits(&s->pb, 6, sub->type_code);
1225
        put_bits(&s->pb, 1, 0); /* no wasted bits */
1226

    
1227
        /* subframe */
1228
        if(sub->type == FLAC_SUBFRAME_CONSTANT) {
1229
            output_subframe_constant(s, ch);
1230
        } else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
1231
            output_subframe_verbatim(s, ch);
1232
        } else if(sub->type == FLAC_SUBFRAME_FIXED) {
1233
            output_subframe_fixed(s, ch);
1234
        } else if(sub->type == FLAC_SUBFRAME_LPC) {
1235
            output_subframe_lpc(s, ch);
1236
        }
1237
    }
1238
}
1239

    
1240
static void output_frame_footer(FlacEncodeContext *s)
1241
{
1242
    int crc;
1243
    flush_put_bits(&s->pb);
1244
    crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
1245
                          s->pb.buf, put_bits_count(&s->pb)>>3));
1246
    put_bits(&s->pb, 16, crc);
1247
    flush_put_bits(&s->pb);
1248
}
1249

    
1250
static void update_md5_sum(FlacEncodeContext *s, int16_t *samples)
1251
{
1252
#ifdef WORDS_BIGENDIAN
1253
    int i;
1254
    for(i = 0; i < s->frame.blocksize*s->channels; i++) {
1255
        int16_t smp = le2me_16(samples[i]);
1256
        av_md5_update(s->md5ctx, (uint8_t *)&smp, 2);
1257
    }
1258
#else
1259
    av_md5_update(s->md5ctx, (uint8_t *)samples, s->frame.blocksize*s->channels*2);
1260
#endif
1261
}
1262

    
1263
static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
1264
                             int buf_size, void *data)
1265
{
1266
    int ch;
1267
    FlacEncodeContext *s;
1268
    int16_t *samples = data;
1269
    int out_bytes;
1270
    int reencoded=0;
1271

    
1272
    s = avctx->priv_data;
1273

    
1274
    if(buf_size < s->max_framesize*2) {
1275
        av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");
1276
        return 0;
1277
    }
1278

    
1279
    /* when the last block is reached, update the header in extradata */
1280
    if (!data) {
1281
        av_md5_final(s->md5ctx, s->md5sum);
1282
        write_streaminfo(s, avctx->extradata);
1283
        return 0;
1284
    }
1285

    
1286
    init_frame(s);
1287

    
1288
    copy_samples(s, samples);
1289

    
1290
    channel_decorrelation(s);
1291

    
1292
    for(ch=0; ch<s->channels; ch++) {
1293
        encode_residual(s, ch);
1294
    }
1295

    
1296
write_frame:
1297
    init_put_bits(&s->pb, frame, buf_size);
1298
    output_frame_header(s);
1299
    output_subframes(s);
1300
    output_frame_footer(s);
1301
    out_bytes = put_bits_count(&s->pb) >> 3;
1302

    
1303
    if(out_bytes > s->max_framesize) {
1304
        if(reencoded) {
1305
            /* still too large. must be an error. */
1306
            av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
1307
            return -1;
1308
        }
1309

    
1310
        /* frame too large. use verbatim mode */
1311
        for(ch=0; ch<s->channels; ch++) {
1312
            encode_residual_v(s, ch);
1313
        }
1314
        reencoded = 1;
1315
        goto write_frame;
1316
    }
1317

    
1318
    s->frame_count++;
1319
    s->sample_count += avctx->frame_size;
1320
    update_md5_sum(s, samples);
1321

    
1322
    return out_bytes;
1323
}
1324

    
1325
static av_cold int flac_encode_close(AVCodecContext *avctx)
1326
{
1327
    if (avctx->priv_data) {
1328
        FlacEncodeContext *s = avctx->priv_data;
1329
        av_freep(&s->md5ctx);
1330
    }
1331
    av_freep(&avctx->extradata);
1332
    avctx->extradata_size = 0;
1333
    av_freep(&avctx->coded_frame);
1334
    return 0;
1335
}
1336

    
1337
AVCodec flac_encoder = {
1338
    "flac",
1339
    CODEC_TYPE_AUDIO,
1340
    CODEC_ID_FLAC,
1341
    sizeof(FlacEncodeContext),
1342
    flac_encode_init,
1343
    flac_encode_frame,
1344
    flac_encode_close,
1345
    NULL,
1346
    .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
1347
    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1348
    .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1349
};