Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacenc.c @ 72415b2a

History | View | Annotate | Download (37.9 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
static void encode_residual_verbatim(int32_t *res, int32_t *smp, int n)
556
{
557
    assert(n > 0);
558
    memcpy(res, smp, n * sizeof(int32_t));
559
}
560

    
561
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
562
                                  int order)
563
{
564
    int i;
565

    
566
    for(i=0; i<order; i++) {
567
        res[i] = smp[i];
568
    }
569

    
570
    if(order==0){
571
        for(i=order; i<n; i++)
572
            res[i]= smp[i];
573
    }else if(order==1){
574
        for(i=order; i<n; i++)
575
            res[i]= smp[i] - smp[i-1];
576
    }else if(order==2){
577
        int a = smp[order-1] - smp[order-2];
578
        for(i=order; i<n; i+=2) {
579
            int b = smp[i] - smp[i-1];
580
            res[i]= b - a;
581
            a = smp[i+1] - smp[i];
582
            res[i+1]= a - b;
583
        }
584
    }else if(order==3){
585
        int a = smp[order-1] - smp[order-2];
586
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
587
        for(i=order; i<n; i+=2) {
588
            int b = smp[i] - smp[i-1];
589
            int d = b - a;
590
            res[i]= d - c;
591
            a = smp[i+1] - smp[i];
592
            c = a - b;
593
            res[i+1]= c - d;
594
        }
595
    }else{
596
        int a = smp[order-1] - smp[order-2];
597
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
598
        int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
599
        for(i=order; i<n; i+=2) {
600
            int b = smp[i] - smp[i-1];
601
            int d = b - a;
602
            int f = d - c;
603
            res[i]= f - e;
604
            a = smp[i+1] - smp[i];
605
            c = a - b;
606
            e = c - d;
607
            res[i+1]= e - f;
608
        }
609
    }
610
}
611

    
612
#define LPC1(x) {\
613
    int c = coefs[(x)-1];\
614
    p0 += c*s;\
615
    s = smp[i-(x)+1];\
616
    p1 += c*s;\
617
}
618

    
619
static av_always_inline void encode_residual_lpc_unrolled(
620
    int32_t *res, const int32_t *smp, int n,
621
    int order, const int32_t *coefs, int shift, int big)
622
{
623
    int i;
624
    for(i=order; i<n; i+=2) {
625
        int s = smp[i-order];
626
        int p0 = 0, p1 = 0;
627
        if(big) {
628
            switch(order) {
629
                case 32: LPC1(32)
630
                case 31: LPC1(31)
631
                case 30: LPC1(30)
632
                case 29: LPC1(29)
633
                case 28: LPC1(28)
634
                case 27: LPC1(27)
635
                case 26: LPC1(26)
636
                case 25: LPC1(25)
637
                case 24: LPC1(24)
638
                case 23: LPC1(23)
639
                case 22: LPC1(22)
640
                case 21: LPC1(21)
641
                case 20: LPC1(20)
642
                case 19: LPC1(19)
643
                case 18: LPC1(18)
644
                case 17: LPC1(17)
645
                case 16: LPC1(16)
646
                case 15: LPC1(15)
647
                case 14: LPC1(14)
648
                case 13: LPC1(13)
649
                case 12: LPC1(12)
650
                case 11: LPC1(11)
651
                case 10: LPC1(10)
652
                case  9: LPC1( 9)
653
                         LPC1( 8)
654
                         LPC1( 7)
655
                         LPC1( 6)
656
                         LPC1( 5)
657
                         LPC1( 4)
658
                         LPC1( 3)
659
                         LPC1( 2)
660
                         LPC1( 1)
661
            }
662
        } else {
663
            switch(order) {
664
                case  8: LPC1( 8)
665
                case  7: LPC1( 7)
666
                case  6: LPC1( 6)
667
                case  5: LPC1( 5)
668
                case  4: LPC1( 4)
669
                case  3: LPC1( 3)
670
                case  2: LPC1( 2)
671
                case  1: LPC1( 1)
672
            }
673
        }
674
        res[i  ] = smp[i  ] - (p0 >> shift);
675
        res[i+1] = smp[i+1] - (p1 >> shift);
676
    }
677
}
678

    
679
static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
680
                                int order, const int32_t *coefs, int shift)
681
{
682
    int i;
683
    for(i=0; i<order; i++) {
684
        res[i] = smp[i];
685
    }
686
#if CONFIG_SMALL
687
    for(i=order; i<n; i+=2) {
688
        int j;
689
        int s = smp[i];
690
        int p0 = 0, p1 = 0;
691
        for(j=0; j<order; j++) {
692
            int c = coefs[j];
693
            p1 += c*s;
694
            s = smp[i-j-1];
695
            p0 += c*s;
696
        }
697
        res[i  ] = smp[i  ] - (p0 >> shift);
698
        res[i+1] = smp[i+1] - (p1 >> shift);
699
    }
700
#else
701
    switch(order) {
702
        case  1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break;
703
        case  2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break;
704
        case  3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break;
705
        case  4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break;
706
        case  5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break;
707
        case  6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break;
708
        case  7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break;
709
        case  8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break;
710
        default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break;
711
    }
712
#endif
713
}
714

    
715
static int encode_residual(FlacEncodeContext *ctx, int ch)
716
{
717
    int i, n;
718
    int min_order, max_order, opt_order, precision, omethod;
719
    int min_porder, max_porder;
720
    FlacFrame *frame;
721
    FlacSubframe *sub;
722
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
723
    int shift[MAX_LPC_ORDER];
724
    int32_t *res, *smp;
725

    
726
    frame = &ctx->frame;
727
    sub = &frame->subframes[ch];
728
    res = sub->residual;
729
    smp = sub->samples;
730
    n = frame->blocksize;
731

    
732
    /* CONSTANT */
733
    for(i=1; i<n; i++) {
734
        if(smp[i] != smp[0]) break;
735
    }
736
    if(i == n) {
737
        sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
738
        res[0] = smp[0];
739
        return sub->obits;
740
    }
741

    
742
    /* VERBATIM */
743
    if(n < 5) {
744
        sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
745
        encode_residual_verbatim(res, smp, n);
746
        return sub->obits * n;
747
    }
748

    
749
    min_order = ctx->options.min_prediction_order;
750
    max_order = ctx->options.max_prediction_order;
751
    min_porder = ctx->options.min_partition_order;
752
    max_porder = ctx->options.max_partition_order;
753
    precision = ctx->options.lpc_coeff_precision;
754
    omethod = ctx->options.prediction_order_method;
755

    
756
    /* FIXED */
757
    if(!ctx->options.use_lpc || max_order == 0 || (n <= max_order)) {
758
        uint32_t bits[MAX_FIXED_ORDER+1];
759
        if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;
760
        opt_order = 0;
761
        bits[0] = UINT32_MAX;
762
        for(i=min_order; i<=max_order; i++) {
763
            encode_residual_fixed(res, smp, n, i);
764
            bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
765
                                             n, i, sub->obits);
766
            if(bits[i] < bits[opt_order]) {
767
                opt_order = i;
768
            }
769
        }
770
        sub->order = opt_order;
771
        sub->type = FLAC_SUBFRAME_FIXED;
772
        sub->type_code = sub->type | sub->order;
773
        if(sub->order != max_order) {
774
            encode_residual_fixed(res, smp, n, sub->order);
775
            return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
776
                                          sub->order, sub->obits);
777
        }
778
        return bits[sub->order];
779
    }
780

    
781
    /* LPC */
782
    opt_order = ff_lpc_calc_coefs(&ctx->dsp, smp, n, min_order, max_order,
783
                                  precision, coefs, shift, ctx->options.use_lpc,
784
                                  omethod, MAX_LPC_SHIFT, 0);
785

    
786
    if(omethod == ORDER_METHOD_2LEVEL ||
787
       omethod == ORDER_METHOD_4LEVEL ||
788
       omethod == ORDER_METHOD_8LEVEL) {
789
        int levels = 1 << omethod;
790
        uint32_t bits[levels];
791
        int order;
792
        int opt_index = levels-1;
793
        opt_order = max_order-1;
794
        bits[opt_index] = UINT32_MAX;
795
        for(i=levels-1; i>=0; i--) {
796
            order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
797
            if(order < 0) order = 0;
798
            encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
799
            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
800
                                           res, n, order+1, sub->obits, precision);
801
            if(bits[i] < bits[opt_index]) {
802
                opt_index = i;
803
                opt_order = order;
804
            }
805
        }
806
        opt_order++;
807
    } else if(omethod == ORDER_METHOD_SEARCH) {
808
        // brute-force optimal order search
809
        uint32_t bits[MAX_LPC_ORDER];
810
        opt_order = 0;
811
        bits[0] = UINT32_MAX;
812
        for(i=min_order-1; i<max_order; i++) {
813
            encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
814
            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
815
                                           res, n, i+1, sub->obits, precision);
816
            if(bits[i] < bits[opt_order]) {
817
                opt_order = i;
818
            }
819
        }
820
        opt_order++;
821
    } else if(omethod == ORDER_METHOD_LOG) {
822
        uint32_t bits[MAX_LPC_ORDER];
823
        int step;
824

    
825
        opt_order= min_order - 1 + (max_order-min_order)/3;
826
        memset(bits, -1, sizeof(bits));
827

    
828
        for(step=16 ;step; step>>=1){
829
            int last= opt_order;
830
            for(i=last-step; i<=last+step; i+= step){
831
                if(i<min_order-1 || i>=max_order || bits[i] < UINT32_MAX)
832
                    continue;
833
                encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
834
                bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
835
                                            res, n, i+1, sub->obits, precision);
836
                if(bits[i] < bits[opt_order])
837
                    opt_order= i;
838
            }
839
        }
840
        opt_order++;
841
    }
842

    
843
    sub->order = opt_order;
844
    sub->type = FLAC_SUBFRAME_LPC;
845
    sub->type_code = sub->type | (sub->order-1);
846
    sub->shift = shift[sub->order-1];
847
    for(i=0; i<sub->order; i++) {
848
        sub->coefs[i] = coefs[sub->order-1][i];
849
    }
850
    encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
851
    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
852
                                sub->obits, precision);
853
}
854

    
855
static int encode_residual_v(FlacEncodeContext *ctx, int ch)
856
{
857
    int i, n;
858
    FlacFrame *frame;
859
    FlacSubframe *sub;
860
    int32_t *res, *smp;
861

    
862
    frame = &ctx->frame;
863
    sub = &frame->subframes[ch];
864
    res = sub->residual;
865
    smp = sub->samples;
866
    n = frame->blocksize;
867

    
868
    /* CONSTANT */
869
    for(i=1; i<n; i++) {
870
        if(smp[i] != smp[0]) break;
871
    }
872
    if(i == n) {
873
        sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
874
        res[0] = smp[0];
875
        return sub->obits;
876
    }
877

    
878
    /* VERBATIM */
879
    sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
880
    encode_residual_verbatim(res, smp, n);
881
    return sub->obits * n;
882
}
883

    
884
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
885
{
886
    int i, best;
887
    int32_t lt, rt;
888
    uint64_t sum[4];
889
    uint64_t score[4];
890
    int k;
891

    
892
    /* calculate sum of 2nd order residual for each channel */
893
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
894
    for(i=2; i<n; i++) {
895
        lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
896
        rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
897
        sum[2] += FFABS((lt + rt) >> 1);
898
        sum[3] += FFABS(lt - rt);
899
        sum[0] += FFABS(lt);
900
        sum[1] += FFABS(rt);
901
    }
902
    /* estimate bit counts */
903
    for(i=0; i<4; i++) {
904
        k = find_optimal_param(2*sum[i], n);
905
        sum[i] = rice_encode_count(2*sum[i], n, k);
906
    }
907

    
908
    /* calculate score for each mode */
909
    score[0] = sum[0] + sum[1];
910
    score[1] = sum[0] + sum[3];
911
    score[2] = sum[1] + sum[3];
912
    score[3] = sum[2] + sum[3];
913

    
914
    /* return mode with lowest score */
915
    best = 0;
916
    for(i=1; i<4; i++) {
917
        if(score[i] < score[best]) {
918
            best = i;
919
        }
920
    }
921
    if(best == 0) {
922
        return FLAC_CHMODE_INDEPENDENT;
923
    } else if(best == 1) {
924
        return FLAC_CHMODE_LEFT_SIDE;
925
    } else if(best == 2) {
926
        return FLAC_CHMODE_RIGHT_SIDE;
927
    } else {
928
        return FLAC_CHMODE_MID_SIDE;
929
    }
930
}
931

    
932
/**
933
 * Perform stereo channel decorrelation
934
 */
935
static void channel_decorrelation(FlacEncodeContext *ctx)
936
{
937
    FlacFrame *frame;
938
    int32_t *left, *right;
939
    int i, n;
940

    
941
    frame = &ctx->frame;
942
    n = frame->blocksize;
943
    left  = frame->subframes[0].samples;
944
    right = frame->subframes[1].samples;
945

    
946
    if(ctx->channels != 2) {
947
        frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
948
        return;
949
    }
950

    
951
    frame->ch_mode = estimate_stereo_mode(left, right, n);
952

    
953
    /* perform decorrelation and adjust bits-per-sample */
954
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
955
        return;
956
    }
957
    if(frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
958
        int32_t tmp;
959
        for(i=0; i<n; i++) {
960
            tmp = left[i];
961
            left[i] = (tmp + right[i]) >> 1;
962
            right[i] = tmp - right[i];
963
        }
964
        frame->subframes[1].obits++;
965
    } else if(frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
966
        for(i=0; i<n; i++) {
967
            right[i] = left[i] - right[i];
968
        }
969
        frame->subframes[1].obits++;
970
    } else {
971
        for(i=0; i<n; i++) {
972
            left[i] -= right[i];
973
        }
974
        frame->subframes[0].obits++;
975
    }
976
}
977

    
978
static void write_utf8(PutBitContext *pb, uint32_t val)
979
{
980
    uint8_t tmp;
981
    PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
982
}
983

    
984
static void output_frame_header(FlacEncodeContext *s)
985
{
986
    FlacFrame *frame;
987
    int crc;
988

    
989
    frame = &s->frame;
990

    
991
    put_bits(&s->pb, 16, 0xFFF8);
992
    put_bits(&s->pb, 4, frame->bs_code[0]);
993
    put_bits(&s->pb, 4, s->sr_code[0]);
994
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
995
        put_bits(&s->pb, 4, s->channels-1);
996
    } else {
997
        put_bits(&s->pb, 4, frame->ch_mode);
998
    }
999
    put_bits(&s->pb, 3, 4); /* bits-per-sample code */
1000
    put_bits(&s->pb, 1, 0);
1001
    write_utf8(&s->pb, s->frame_count);
1002
    if(frame->bs_code[0] == 6) {
1003
        put_bits(&s->pb, 8, frame->bs_code[1]);
1004
    } else if(frame->bs_code[0] == 7) {
1005
        put_bits(&s->pb, 16, frame->bs_code[1]);
1006
    }
1007
    if(s->sr_code[0] == 12) {
1008
        put_bits(&s->pb, 8, s->sr_code[1]);
1009
    } else if(s->sr_code[0] > 12) {
1010
        put_bits(&s->pb, 16, s->sr_code[1]);
1011
    }
1012
    flush_put_bits(&s->pb);
1013
    crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
1014
                 s->pb.buf, put_bits_count(&s->pb)>>3);
1015
    put_bits(&s->pb, 8, crc);
1016
}
1017

    
1018
static void output_subframe_constant(FlacEncodeContext *s, int ch)
1019
{
1020
    FlacSubframe *sub;
1021
    int32_t res;
1022

    
1023
    sub = &s->frame.subframes[ch];
1024
    res = sub->residual[0];
1025
    put_sbits(&s->pb, sub->obits, res);
1026
}
1027

    
1028
static void output_subframe_verbatim(FlacEncodeContext *s, int ch)
1029
{
1030
    int i;
1031
    FlacFrame *frame;
1032
    FlacSubframe *sub;
1033
    int32_t res;
1034

    
1035
    frame = &s->frame;
1036
    sub = &frame->subframes[ch];
1037

    
1038
    for(i=0; i<frame->blocksize; i++) {
1039
        res = sub->residual[i];
1040
        put_sbits(&s->pb, sub->obits, res);
1041
    }
1042
}
1043

    
1044
static void output_residual(FlacEncodeContext *ctx, int ch)
1045
{
1046
    int i, j, p, n, parts;
1047
    int k, porder, psize, res_cnt;
1048
    FlacFrame *frame;
1049
    FlacSubframe *sub;
1050
    int32_t *res;
1051

    
1052
    frame = &ctx->frame;
1053
    sub = &frame->subframes[ch];
1054
    res = sub->residual;
1055
    n = frame->blocksize;
1056

    
1057
    /* rice-encoded block */
1058
    put_bits(&ctx->pb, 2, 0);
1059

    
1060
    /* partition order */
1061
    porder = sub->rc.porder;
1062
    psize = n >> porder;
1063
    parts = (1 << porder);
1064
    put_bits(&ctx->pb, 4, porder);
1065
    res_cnt = psize - sub->order;
1066

    
1067
    /* residual */
1068
    j = sub->order;
1069
    for(p=0; p<parts; p++) {
1070
        k = sub->rc.params[p];
1071
        put_bits(&ctx->pb, 4, k);
1072
        if(p == 1) res_cnt = psize;
1073
        for(i=0; i<res_cnt && j<n; i++, j++) {
1074
            set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
1075
        }
1076
    }
1077
}
1078

    
1079
static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
1080
{
1081
    int i;
1082
    FlacFrame *frame;
1083
    FlacSubframe *sub;
1084

    
1085
    frame = &ctx->frame;
1086
    sub = &frame->subframes[ch];
1087

    
1088
    /* warm-up samples */
1089
    for(i=0; i<sub->order; i++) {
1090
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1091
    }
1092

    
1093
    /* residual */
1094
    output_residual(ctx, ch);
1095
}
1096

    
1097
static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
1098
{
1099
    int i, cbits;
1100
    FlacFrame *frame;
1101
    FlacSubframe *sub;
1102

    
1103
    frame = &ctx->frame;
1104
    sub = &frame->subframes[ch];
1105

    
1106
    /* warm-up samples */
1107
    for(i=0; i<sub->order; i++) {
1108
        put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1109
    }
1110

    
1111
    /* LPC coefficients */
1112
    cbits = ctx->options.lpc_coeff_precision;
1113
    put_bits(&ctx->pb, 4, cbits-1);
1114
    put_sbits(&ctx->pb, 5, sub->shift);
1115
    for(i=0; i<sub->order; i++) {
1116
        put_sbits(&ctx->pb, cbits, sub->coefs[i]);
1117
    }
1118

    
1119
    /* residual */
1120
    output_residual(ctx, ch);
1121
}
1122

    
1123
static void output_subframes(FlacEncodeContext *s)
1124
{
1125
    FlacFrame *frame;
1126
    FlacSubframe *sub;
1127
    int ch;
1128

    
1129
    frame = &s->frame;
1130

    
1131
    for(ch=0; ch<s->channels; ch++) {
1132
        sub = &frame->subframes[ch];
1133

    
1134
        /* subframe header */
1135
        put_bits(&s->pb, 1, 0);
1136
        put_bits(&s->pb, 6, sub->type_code);
1137
        put_bits(&s->pb, 1, 0); /* no wasted bits */
1138

    
1139
        /* subframe */
1140
        if(sub->type == FLAC_SUBFRAME_CONSTANT) {
1141
            output_subframe_constant(s, ch);
1142
        } else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
1143
            output_subframe_verbatim(s, ch);
1144
        } else if(sub->type == FLAC_SUBFRAME_FIXED) {
1145
            output_subframe_fixed(s, ch);
1146
        } else if(sub->type == FLAC_SUBFRAME_LPC) {
1147
            output_subframe_lpc(s, ch);
1148
        }
1149
    }
1150
}
1151

    
1152
static void output_frame_footer(FlacEncodeContext *s)
1153
{
1154
    int crc;
1155
    flush_put_bits(&s->pb);
1156
    crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
1157
                          s->pb.buf, put_bits_count(&s->pb)>>3));
1158
    put_bits(&s->pb, 16, crc);
1159
    flush_put_bits(&s->pb);
1160
}
1161

    
1162
static void update_md5_sum(FlacEncodeContext *s, int16_t *samples)
1163
{
1164
#if HAVE_BIGENDIAN
1165
    int i;
1166
    for(i = 0; i < s->frame.blocksize*s->channels; i++) {
1167
        int16_t smp = le2me_16(samples[i]);
1168
        av_md5_update(s->md5ctx, (uint8_t *)&smp, 2);
1169
    }
1170
#else
1171
    av_md5_update(s->md5ctx, (uint8_t *)samples, s->frame.blocksize*s->channels*2);
1172
#endif
1173
}
1174

    
1175
static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
1176
                             int buf_size, void *data)
1177
{
1178
    int ch;
1179
    FlacEncodeContext *s;
1180
    int16_t *samples = data;
1181
    int out_bytes;
1182
    int reencoded=0;
1183

    
1184
    s = avctx->priv_data;
1185

    
1186
    if(buf_size < s->max_framesize*2) {
1187
        av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");
1188
        return 0;
1189
    }
1190

    
1191
    /* when the last block is reached, update the header in extradata */
1192
    if (!data) {
1193
        s->max_framesize = s->max_encoded_framesize;
1194
        av_md5_final(s->md5ctx, s->md5sum);
1195
        write_streaminfo(s, avctx->extradata);
1196
        return 0;
1197
    }
1198

    
1199
    init_frame(s);
1200

    
1201
    copy_samples(s, samples);
1202

    
1203
    channel_decorrelation(s);
1204

    
1205
    for(ch=0; ch<s->channels; ch++) {
1206
        encode_residual(s, ch);
1207
    }
1208

    
1209
write_frame:
1210
    init_put_bits(&s->pb, frame, buf_size);
1211
    output_frame_header(s);
1212
    output_subframes(s);
1213
    output_frame_footer(s);
1214
    out_bytes = put_bits_count(&s->pb) >> 3;
1215

    
1216
    if(out_bytes > s->max_framesize) {
1217
        if(reencoded) {
1218
            /* still too large. must be an error. */
1219
            av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
1220
            return -1;
1221
        }
1222

    
1223
        /* frame too large. use verbatim mode */
1224
        for(ch=0; ch<s->channels; ch++) {
1225
            encode_residual_v(s, ch);
1226
        }
1227
        reencoded = 1;
1228
        goto write_frame;
1229
    }
1230

    
1231
    s->frame_count++;
1232
    s->sample_count += avctx->frame_size;
1233
    update_md5_sum(s, samples);
1234
    if (out_bytes > s->max_encoded_framesize)
1235
        s->max_encoded_framesize = out_bytes;
1236
    if (out_bytes < s->min_framesize)
1237
        s->min_framesize = out_bytes;
1238

    
1239
    return out_bytes;
1240
}
1241

    
1242
static av_cold int flac_encode_close(AVCodecContext *avctx)
1243
{
1244
    if (avctx->priv_data) {
1245
        FlacEncodeContext *s = avctx->priv_data;
1246
        av_freep(&s->md5ctx);
1247
    }
1248
    av_freep(&avctx->extradata);
1249
    avctx->extradata_size = 0;
1250
    av_freep(&avctx->coded_frame);
1251
    return 0;
1252
}
1253

    
1254
AVCodec flac_encoder = {
1255
    "flac",
1256
    AVMEDIA_TYPE_AUDIO,
1257
    CODEC_ID_FLAC,
1258
    sizeof(FlacEncodeContext),
1259
    flac_encode_init,
1260
    flac_encode_frame,
1261
    flac_encode_close,
1262
    NULL,
1263
    .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
1264
    .sample_fmts = (const enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1265
    .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1266
};