Statistics
| Branch: | Revision:

ffmpeg / libavcodec / flacenc.c @ 2874c81c

History | View | Annotate | Download (37.9 KB)

1 9e96ab03 Michael Niedermayer
/**
2
 * FLAC audio encoder
3 38c1a5c4 Justin Ruggles
 * Copyright (c) 2006  Justin Ruggles <justin.ruggles@gmail.com>
4 9e96ab03 Michael Niedermayer
 *
5 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8 9e96ab03 Michael Niedermayer
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
11 9e96ab03 Michael Niedermayer
 *
12 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
13 9e96ab03 Michael Niedermayer
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
19 9e96ab03 Michael Niedermayer
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22 245976da Diego Biurrun
#include "libavutil/crc.h"
23 a9f8587e Justin Ruggles
#include "libavutil/md5.h"
24 9e96ab03 Michael Niedermayer
#include "avcodec.h"
25 9106a698 Stefano Sabatini
#include "get_bits.h"
26 6810b93a Loren Merritt
#include "dsputil.h"
27 9e96ab03 Michael Niedermayer
#include "golomb.h"
28 c50da3ad Ramiro Polla
#include "lpc.h"
29 07d16e2e Justin Ruggles
#include "flac.h"
30 d4df4e50 Justin Ruggles
#include "flacdata.h"
31 9e96ab03 Michael Niedermayer
32
#define FLAC_SUBFRAME_CONSTANT  0
33
#define FLAC_SUBFRAME_VERBATIM  1
34
#define FLAC_SUBFRAME_FIXED     8
35
#define FLAC_SUBFRAME_LPC      32
36
37 a403fc03 Justin Ruggles
#define MAX_FIXED_ORDER     4
38
#define MAX_PARTITION_ORDER 8
39
#define MAX_PARTITIONS     (1 << MAX_PARTITION_ORDER)
40
#define MAX_LPC_PRECISION  15
41
#define MAX_LPC_SHIFT      15
42
#define MAX_RICE_PARAM     14
43
44
typedef struct CompressionOptions {
45
    int compression_level;
46
    int block_time_ms;
47
    int use_lpc;
48
    int lpc_coeff_precision;
49
    int min_prediction_order;
50
    int max_prediction_order;
51
    int prediction_order_method;
52
    int min_partition_order;
53
    int max_partition_order;
54
} CompressionOptions;
55
56 e71bcc37 Justin Ruggles
typedef struct RiceContext {
57
    int porder;
58 a403fc03 Justin Ruggles
    int params[MAX_PARTITIONS];
59 e71bcc37 Justin Ruggles
} RiceContext;
60
61 9e96ab03 Michael Niedermayer
typedef struct FlacSubframe {
62
    int type;
63
    int type_code;
64
    int obits;
65
    int order;
66 a403fc03 Justin Ruggles
    int32_t coefs[MAX_LPC_ORDER];
67
    int shift;
68 e71bcc37 Justin Ruggles
    RiceContext rc;
69 9e96ab03 Michael Niedermayer
    int32_t samples[FLAC_MAX_BLOCKSIZE];
70 0d2caa37 Loren Merritt
    int32_t residual[FLAC_MAX_BLOCKSIZE+1];
71 9e96ab03 Michael Niedermayer
} FlacSubframe;
72
73
typedef struct FlacFrame {
74 07d16e2e Justin Ruggles
    FlacSubframe subframes[FLAC_MAX_CHANNELS];
75 9e96ab03 Michael Niedermayer
    int blocksize;
76
    int bs_code[2];
77
    uint8_t crc8;
78
    int ch_mode;
79
} FlacFrame;
80
81
typedef struct FlacEncodeContext {
82
    PutBitContext pb;
83 f1216221 Justin Ruggles
    int channels;
84
    int samplerate;
85 9e96ab03 Michael Niedermayer
    int sr_code[2];
86 0bc08ed9 Justin Ruggles
    int max_blocksize;
87 6682ae42 Justin Ruggles
    int min_framesize;
88 f1216221 Justin Ruggles
    int max_framesize;
89 6682ae42 Justin Ruggles
    int max_encoded_framesize;
90 9e96ab03 Michael Niedermayer
    uint32_t frame_count;
91 e1a12934 Justin Ruggles
    uint64_t sample_count;
92 a9f8587e Justin Ruggles
    uint8_t md5sum[16];
93 9e96ab03 Michael Niedermayer
    FlacFrame frame;
94 a403fc03 Justin Ruggles
    CompressionOptions options;
95 e71bcc37 Justin Ruggles
    AVCodecContext *avctx;
96 6810b93a Loren Merritt
    DSPContext dsp;
97 a9f8587e Justin Ruggles
    struct AVMD5 *md5ctx;
98 9e96ab03 Michael Niedermayer
} FlacEncodeContext;
99
100
/**
101
 * Writes streaminfo metadata block to byte array
102
 */
103
static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
104
{
105
    PutBitContext pb;
106
107
    memset(header, 0, FLAC_STREAMINFO_SIZE);
108
    init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
109
110
    /* streaminfo metadata block */
111 0bc08ed9 Justin Ruggles
    put_bits(&pb, 16, s->max_blocksize);
112
    put_bits(&pb, 16, s->max_blocksize);
113 6682ae42 Justin Ruggles
    put_bits(&pb, 24, s->min_framesize);
114 9e96ab03 Michael Niedermayer
    put_bits(&pb, 24, s->max_framesize);
115
    put_bits(&pb, 20, s->samplerate);
116
    put_bits(&pb, 3, s->channels-1);
117
    put_bits(&pb, 5, 15);       /* bits per sample - 1 */
118 e1a12934 Justin Ruggles
    /* write 36-bit sample count in 2 put_bits() calls */
119
    put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
120
    put_bits(&pb, 12,  s->sample_count & 0x000000FFFLL);
121 9e96ab03 Michael Niedermayer
    flush_put_bits(&pb);
122 a9f8587e Justin Ruggles
    memcpy(&header[18], s->md5sum, 16);
123 9e96ab03 Michael Niedermayer
}
124
125
/**
126
 * Sets blocksize based on samplerate
127
 * Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
128
 */
129 a403fc03 Justin Ruggles
static int select_blocksize(int samplerate, int block_time_ms)
130 9e96ab03 Michael Niedermayer
{
131
    int i;
132
    int target;
133
    int blocksize;
134
135
    assert(samplerate > 0);
136 d4df4e50 Justin Ruggles
    blocksize = ff_flac_blocksize_table[1];
137 a403fc03 Justin Ruggles
    target = (samplerate * block_time_ms) / 1000;
138 d1015e88 Michael Niedermayer
    for(i=0; i<16; i++) {
139 d4df4e50 Justin Ruggles
        if(target >= ff_flac_blocksize_table[i] && ff_flac_blocksize_table[i] > blocksize) {
140
            blocksize = ff_flac_blocksize_table[i];
141 9e96ab03 Michael Niedermayer
        }
142
    }
143
    return blocksize;
144
}
145
146 98a6fff9 Zuxy Meng
static av_cold int flac_encode_init(AVCodecContext *avctx)
147 9e96ab03 Michael Niedermayer
{
148
    int freq = avctx->sample_rate;
149
    int channels = avctx->channels;
150
    FlacEncodeContext *s = avctx->priv_data;
151 7c69b830 Michael Niedermayer
    int i, level;
152 9e96ab03 Michael Niedermayer
    uint8_t *streaminfo;
153
154 e71bcc37 Justin Ruggles
    s->avctx = avctx;
155
156 6810b93a Loren Merritt
    dsputil_init(&s->dsp, avctx);
157
158 9e96ab03 Michael Niedermayer
    if(avctx->sample_fmt != SAMPLE_FMT_S16) {
159
        return -1;
160
    }
161
162 07d16e2e Justin Ruggles
    if(channels < 1 || channels > FLAC_MAX_CHANNELS) {
163 9e96ab03 Michael Niedermayer
        return -1;
164
    }
165
    s->channels = channels;
166
167
    /* find samplerate in table */
168
    if(freq < 1)
169
        return -1;
170
    for(i=4; i<12; i++) {
171 d4df4e50 Justin Ruggles
        if(freq == ff_flac_sample_rate_table[i]) {
172
            s->samplerate = ff_flac_sample_rate_table[i];
173 9e96ab03 Michael Niedermayer
            s->sr_code[0] = i;
174
            s->sr_code[1] = 0;
175
            break;
176
        }
177
    }
178
    /* if not in table, samplerate is non-standard */
179
    if(i == 12) {
180
        if(freq % 1000 == 0 && freq < 255000) {
181
            s->sr_code[0] = 12;
182
            s->sr_code[1] = freq / 1000;
183
        } else if(freq % 10 == 0 && freq < 655350) {
184
            s->sr_code[0] = 14;
185
            s->sr_code[1] = freq / 10;
186
        } else if(freq < 65535) {
187
            s->sr_code[0] = 13;
188
            s->sr_code[1] = freq;
189
        } else {
190
            return -1;
191
        }
192
        s->samplerate = freq;
193
    }
194
195 a403fc03 Justin Ruggles
    /* set compression option defaults based on avctx->compression_level */
196
    if(avctx->compression_level < 0) {
197
        s->options.compression_level = 5;
198
    } else {
199
        s->options.compression_level = avctx->compression_level;
200
    }
201
    av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", s->options.compression_level);
202
203 7c69b830 Michael Niedermayer
    level= s->options.compression_level;
204 26053bdc Justin Ruggles
    if(level > 12) {
205 a403fc03 Justin Ruggles
        av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
206
               s->options.compression_level);
207
        return -1;
208
    }
209
210 26053bdc Justin Ruggles
    s->options.block_time_ms       = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
211
    s->options.use_lpc             = ((int[]){  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
212
    s->options.min_prediction_order= ((int[]){  2,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
213
    s->options.max_prediction_order= ((int[]){  3,  4,  4,  6,  8,  8,  8,  8, 12, 12, 12, 32, 32})[level];
214
    s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
215
                                                   ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
216 5f3acd9e Justin Ruggles
                                                   ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG,    ORDER_METHOD_4LEVEL,
217
                                                   ORDER_METHOD_LOG,    ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
218 26053bdc Justin Ruggles
                                                   ORDER_METHOD_SEARCH})[level];
219 e1bbc032 Justin Ruggles
    s->options.min_partition_order = ((int[]){  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0})[level];
220
    s->options.max_partition_order = ((int[]){  2,  2,  3,  3,  3,  8,  8,  8,  8,  8,  8,  8,  8})[level];
221 7c69b830 Michael Niedermayer
222 a403fc03 Justin Ruggles
    /* set compression option overrides from AVCodecContext */
223
    if(avctx->use_lpc >= 0) {
224 f66e4f5f Reimar Döffinger
        s->options.use_lpc = av_clip(avctx->use_lpc, 0, 11);
225 a403fc03 Justin Ruggles
    }
226 ab01b2b8 Michael Niedermayer
    if(s->options.use_lpc == 1)
227
        av_log(avctx, AV_LOG_DEBUG, " use lpc: Levinson-Durbin recursion with Welch window\n");
228
    else if(s->options.use_lpc > 1)
229
        av_log(avctx, AV_LOG_DEBUG, " use lpc: Cholesky factorization\n");
230 a403fc03 Justin Ruggles
231
    if(avctx->min_prediction_order >= 0) {
232
        if(s->options.use_lpc) {
233
            if(avctx->min_prediction_order < MIN_LPC_ORDER ||
234
                    avctx->min_prediction_order > MAX_LPC_ORDER) {
235
                av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
236
                       avctx->min_prediction_order);
237
                return -1;
238
            }
239
        } else {
240
            if(avctx->min_prediction_order > MAX_FIXED_ORDER) {
241
                av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
242
                       avctx->min_prediction_order);
243
                return -1;
244
            }
245
        }
246
        s->options.min_prediction_order = avctx->min_prediction_order;
247
    }
248
    if(avctx->max_prediction_order >= 0) {
249
        if(s->options.use_lpc) {
250
            if(avctx->max_prediction_order < MIN_LPC_ORDER ||
251
                    avctx->max_prediction_order > MAX_LPC_ORDER) {
252
                av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
253
                       avctx->max_prediction_order);
254
                return -1;
255
            }
256
        } else {
257
            if(avctx->max_prediction_order > MAX_FIXED_ORDER) {
258
                av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
259
                       avctx->max_prediction_order);
260
                return -1;
261
            }
262
        }
263
        s->options.max_prediction_order = avctx->max_prediction_order;
264
    }
265
    if(s->options.max_prediction_order < s->options.min_prediction_order) {
266
        av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
267
               s->options.min_prediction_order, s->options.max_prediction_order);
268
        return -1;
269
    }
270
    av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",
271
           s->options.min_prediction_order, s->options.max_prediction_order);
272
273
    if(avctx->prediction_order_method >= 0) {
274 dbb45a3b Michael Niedermayer
        if(avctx->prediction_order_method > ORDER_METHOD_LOG) {
275 a403fc03 Justin Ruggles
            av_log(avctx, AV_LOG_ERROR, "invalid prediction order method: %d\n",
276
                   avctx->prediction_order_method);
277
            return -1;
278
        }
279
        s->options.prediction_order_method = avctx->prediction_order_method;
280
    }
281 26053bdc Justin Ruggles
    switch(s->options.prediction_order_method) {
282 a403fc03 Justin Ruggles
        case ORDER_METHOD_EST:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
283
                                         "estimate"); break;
284
        case ORDER_METHOD_2LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
285
                                         "2-level"); break;
286
        case ORDER_METHOD_4LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
287
                                         "4-level"); break;
288
        case ORDER_METHOD_8LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
289
                                         "8-level"); break;
290
        case ORDER_METHOD_SEARCH: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
291
                                         "full search"); break;
292 dbb45a3b Michael Niedermayer
        case ORDER_METHOD_LOG:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
293
                                         "log search"); break;
294 a403fc03 Justin Ruggles
    }
295
296
    if(avctx->min_partition_order >= 0) {
297
        if(avctx->min_partition_order > MAX_PARTITION_ORDER) {
298
            av_log(avctx, AV_LOG_ERROR, "invalid min partition order: %d\n",
299
                   avctx->min_partition_order);
300
            return -1;
301
        }
302
        s->options.min_partition_order = avctx->min_partition_order;
303
    }
304
    if(avctx->max_partition_order >= 0) {
305
        if(avctx->max_partition_order > MAX_PARTITION_ORDER) {
306
            av_log(avctx, AV_LOG_ERROR, "invalid max partition order: %d\n",
307
                   avctx->max_partition_order);
308
            return -1;
309
        }
310
        s->options.max_partition_order = avctx->max_partition_order;
311
    }
312
    if(s->options.max_partition_order < s->options.min_partition_order) {
313
        av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
314
               s->options.min_partition_order, s->options.max_partition_order);
315
        return -1;
316
    }
317
    av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",
318
           s->options.min_partition_order, s->options.max_partition_order);
319
320
    if(avctx->frame_size > 0) {
321
        if(avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
322 c6375bf2 Justin Ruggles
                avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
323 a403fc03 Justin Ruggles
            av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
324
                   avctx->frame_size);
325
            return -1;
326
        }
327
    } else {
328 42ceeb5f Justin Ruggles
        s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
329 a403fc03 Justin Ruggles
    }
330 0bc08ed9 Justin Ruggles
    s->max_blocksize = s->avctx->frame_size;
331 42ceeb5f Justin Ruggles
    av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->avctx->frame_size);
332 a403fc03 Justin Ruggles
333
    /* set LPC precision */
334
    if(avctx->lpc_coeff_precision > 0) {
335
        if(avctx->lpc_coeff_precision > MAX_LPC_PRECISION) {
336
            av_log(avctx, AV_LOG_ERROR, "invalid lpc coeff precision: %d\n",
337
                   avctx->lpc_coeff_precision);
338
            return -1;
339
        }
340
        s->options.lpc_coeff_precision = avctx->lpc_coeff_precision;
341
    } else {
342 fe790f89 Justin Ruggles
        /* default LPC precision */
343
        s->options.lpc_coeff_precision = 15;
344 a403fc03 Justin Ruggles
    }
345
    av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
346
           s->options.lpc_coeff_precision);
347 9e96ab03 Michael Niedermayer
348 f33aa120 Michael Niedermayer
    /* set maximum encoded frame size in verbatim mode */
349 0fb2182d Justin Ruggles
    s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size,
350
                                                  s->channels, 16);
351 9e96ab03 Michael Niedermayer
352 a9f8587e Justin Ruggles
    /* initialize MD5 context */
353
    s->md5ctx = av_malloc(av_md5_size);
354
    if(!s->md5ctx)
355 2874c81c Stefano Sabatini
        return AVERROR(ENOMEM);
356 a9f8587e Justin Ruggles
    av_md5_init(s->md5ctx);
357
358 9e96ab03 Michael Niedermayer
    streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
359
    write_streaminfo(s, streaminfo);
360
    avctx->extradata = streaminfo;
361
    avctx->extradata_size = FLAC_STREAMINFO_SIZE;
362
363
    s->frame_count = 0;
364 b9b4fc5e Justin Ruggles
    s->min_framesize = s->max_framesize;
365 9e96ab03 Michael Niedermayer
366
    avctx->coded_frame = avcodec_alloc_frame();
367
    avctx->coded_frame->key_frame = 1;
368
369
    return 0;
370
}
371
372 f33aa120 Michael Niedermayer
static void init_frame(FlacEncodeContext *s)
373 9e96ab03 Michael Niedermayer
{
374
    int i, ch;
375
    FlacFrame *frame;
376
377
    frame = &s->frame;
378
379
    for(i=0; i<16; i++) {
380 d4df4e50 Justin Ruggles
        if(s->avctx->frame_size == ff_flac_blocksize_table[i]) {
381
            frame->blocksize = ff_flac_blocksize_table[i];
382 9e96ab03 Michael Niedermayer
            frame->bs_code[0] = i;
383
            frame->bs_code[1] = 0;
384
            break;
385
        }
386
    }
387
    if(i == 16) {
388 42ceeb5f Justin Ruggles
        frame->blocksize = s->avctx->frame_size;
389 9e96ab03 Michael Niedermayer
        if(frame->blocksize <= 256) {
390
            frame->bs_code[0] = 6;
391
            frame->bs_code[1] = frame->blocksize-1;
392
        } else {
393
            frame->bs_code[0] = 7;
394
            frame->bs_code[1] = frame->blocksize-1;
395
        }
396
    }
397
398
    for(ch=0; ch<s->channels; ch++) {
399
        frame->subframes[ch].obits = 16;
400
    }
401
}
402
403
/**
404
 * Copy channel-interleaved input samples into separate subframes
405
 */
406
static void copy_samples(FlacEncodeContext *s, int16_t *samples)
407
{
408
    int i, j, ch;
409
    FlacFrame *frame;
410
411
    frame = &s->frame;
412
    for(i=0,j=0; i<frame->blocksize; i++) {
413
        for(ch=0; ch<s->channels; ch++,j++) {
414
            frame->subframes[ch].samples[i] = samples[j];
415
        }
416
    }
417
}
418
419 e71bcc37 Justin Ruggles
420
#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
421
422 14bd2a9f Loren Merritt
/**
423
 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
424
 */
425 e71bcc37 Justin Ruggles
static int find_optimal_param(uint32_t sum, int n)
426
{
427 14bd2a9f Loren Merritt
    int k;
428
    uint32_t sum2;
429
430
    if(sum <= n>>1)
431
        return 0;
432
    sum2 = sum-(n>>1);
433
    k = av_log2(n<256 ? FASTDIV(sum2,n) : sum2/n);
434
    return FFMIN(k, MAX_RICE_PARAM);
435 e71bcc37 Justin Ruggles
}
436
437
static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
438
                                         uint32_t *sums, int n, int pred_order)
439
{
440
    int i;
441
    int k, cnt, part;
442
    uint32_t all_bits;
443
444
    part = (1 << porder);
445 90f03441 Loren Merritt
    all_bits = 4 * part;
446 e71bcc37 Justin Ruggles
447
    cnt = (n >> porder) - pred_order;
448
    for(i=0; i<part; i++) {
449
        k = find_optimal_param(sums[i], cnt);
450
        rc->params[i] = k;
451
        all_bits += rice_encode_count(sums[i], cnt, k);
452 90f03441 Loren Merritt
        cnt = n >> porder;
453 e71bcc37 Justin Ruggles
    }
454
455
    rc->porder = porder;
456
457
    return all_bits;
458
}
459
460 a403fc03 Justin Ruggles
static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
461
                      uint32_t sums[][MAX_PARTITIONS])
462 e71bcc37 Justin Ruggles
{
463
    int i, j;
464 78f67b7a Michael Niedermayer
    int parts;
465
    uint32_t *res, *res_end;
466 e71bcc37 Justin Ruggles
467
    /* sums for highest level */
468
    parts = (1 << pmax);
469
    res = &data[pred_order];
470 78f67b7a Michael Niedermayer
    res_end = &data[n >> pmax];
471 e71bcc37 Justin Ruggles
    for(i=0; i<parts; i++) {
472 f6215b1b Loren Merritt
        uint32_t sum = 0;
473 78f67b7a Michael Niedermayer
        while(res < res_end){
474 f6215b1b Loren Merritt
            sum += *(res++);
475 e71bcc37 Justin Ruggles
        }
476 f6215b1b Loren Merritt
        sums[pmax][i] = sum;
477 78f67b7a Michael Niedermayer
        res_end+= n >> pmax;
478 e71bcc37 Justin Ruggles
    }
479
    /* sums for lower levels */
480 a403fc03 Justin Ruggles
    for(i=pmax-1; i>=pmin; i--) {
481 e71bcc37 Justin Ruggles
        parts = (1 << i);
482
        for(j=0; j<parts; j++) {
483
            sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
484
        }
485
    }
486
}
487
488 a403fc03 Justin Ruggles
static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
489
                                 int32_t *data, int n, int pred_order)
490 e71bcc37 Justin Ruggles
{
491
    int i;
492 a403fc03 Justin Ruggles
    uint32_t bits[MAX_PARTITION_ORDER+1];
493 e71bcc37 Justin Ruggles
    int opt_porder;
494 a403fc03 Justin Ruggles
    RiceContext tmp_rc;
495 e71bcc37 Justin Ruggles
    uint32_t *udata;
496 a403fc03 Justin Ruggles
    uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];
497 e71bcc37 Justin Ruggles
498 a403fc03 Justin Ruggles
    assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
499
    assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
500
    assert(pmin <= pmax);
501 e71bcc37 Justin Ruggles
502
    udata = av_malloc(n * sizeof(uint32_t));
503
    for(i=0; i<n; i++) {
504
        udata[i] = (2*data[i]) ^ (data[i]>>31);
505
    }
506
507 a403fc03 Justin Ruggles
    calc_sums(pmin, pmax, udata, n, pred_order, sums);
508 e71bcc37 Justin Ruggles
509 a403fc03 Justin Ruggles
    opt_porder = pmin;
510
    bits[pmin] = UINT32_MAX;
511
    for(i=pmin; i<=pmax; i++) {
512
        bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order);
513
        if(bits[i] <= bits[opt_porder]) {
514 e71bcc37 Justin Ruggles
            opt_porder = i;
515 41275956 Michael Niedermayer
            *rc= tmp_rc;
516 e71bcc37 Justin Ruggles
        }
517
    }
518
519
    av_freep(&udata);
520 a403fc03 Justin Ruggles
    return bits[opt_porder];
521 e71bcc37 Justin Ruggles
}
522
523 1e5707b7 Justin Ruggles
static int get_max_p_order(int max_porder, int n, int order)
524
{
525
    int porder = FFMIN(max_porder, av_log2(n^(n-1)));
526
    if(order > 0)
527
        porder = FFMIN(porder, av_log2(n/order));
528
    return porder;
529
}
530
531 a403fc03 Justin Ruggles
static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
532
                                       int32_t *data, int n, int pred_order,
533
                                       int bps)
534 e71bcc37 Justin Ruggles
{
535
    uint32_t bits;
536 1e5707b7 Justin Ruggles
    pmin = get_max_p_order(pmin, n, pred_order);
537
    pmax = get_max_p_order(pmax, n, pred_order);
538 e71bcc37 Justin Ruggles
    bits = pred_order*bps + 6;
539 a403fc03 Justin Ruggles
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
540
    return bits;
541
}
542
543
static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
544
                                     int32_t *data, int n, int pred_order,
545
                                     int bps, int precision)
546
{
547
    uint32_t bits;
548 1e5707b7 Justin Ruggles
    pmin = get_max_p_order(pmin, n, pred_order);
549
    pmax = get_max_p_order(pmax, n, pred_order);
550 a403fc03 Justin Ruggles
    bits = pred_order*bps + 4 + 5 + pred_order*precision + 6;
551
    bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
552 e71bcc37 Justin Ruggles
    return bits;
553
}
554
555
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 a403fc03 Justin Ruggles
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
562
                                  int order)
563 e71bcc37 Justin Ruggles
{
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 a309dce7 Loren Merritt
        int a = smp[order-1] - smp[order-2];
578 bfdd5bc1 Loren Merritt
        for(i=order; i<n; i+=2) {
579 a309dce7 Loren Merritt
            int b = smp[i] - smp[i-1];
580
            res[i]= b - a;
581 bfdd5bc1 Loren Merritt
            a = smp[i+1] - smp[i];
582
            res[i+1]= a - b;
583 a309dce7 Loren Merritt
        }
584 e71bcc37 Justin Ruggles
    }else if(order==3){
585 a309dce7 Loren Merritt
        int a = smp[order-1] - smp[order-2];
586
        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
587 bfdd5bc1 Loren Merritt
        for(i=order; i<n; i+=2) {
588 a309dce7 Loren Merritt
            int b = smp[i] - smp[i-1];
589
            int d = b - a;
590
            res[i]= d - c;
591 bfdd5bc1 Loren Merritt
            a = smp[i+1] - smp[i];
592
            c = a - b;
593
            res[i+1]= c - d;
594 a309dce7 Loren Merritt
        }
595 e71bcc37 Justin Ruggles
    }else{
596 a309dce7 Loren Merritt
        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 bfdd5bc1 Loren Merritt
        for(i=order; i<n; i+=2) {
600 a309dce7 Loren Merritt
            int b = smp[i] - smp[i-1];
601
            int d = b - a;
602
            int f = d - c;
603
            res[i]= f - e;
604 bfdd5bc1 Loren Merritt
            a = smp[i+1] - smp[i];
605
            c = a - b;
606
            e = c - d;
607
            res[i+1]= e - f;
608 a309dce7 Loren Merritt
        }
609 e71bcc37 Justin Ruggles
    }
610
}
611
612 dc44d4ad Loren Merritt
#define LPC1(x) {\
613 b8de3429 Loren Merritt
    int c = coefs[(x)-1];\
614 dc44d4ad Loren Merritt
    p0 += c*s;\
615 b8de3429 Loren Merritt
    s = smp[i-(x)+1];\
616
    p1 += c*s;\
617 dc44d4ad Loren Merritt
}
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 b8de3429 Loren Merritt
        int s = smp[i-order];
626
        int p0 = 0, p1 = 0;
627 dc44d4ad Loren Merritt
        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 b8de3429 Loren Merritt
                         LPC1( 1)
661 dc44d4ad Loren Merritt
            }
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 b8de3429 Loren Merritt
                case  1: LPC1( 1)
672 dc44d4ad Loren Merritt
            }
673
        }
674
        res[i  ] = smp[i  ] - (p0 >> shift);
675
        res[i+1] = smp[i+1] - (p1 >> shift);
676
    }
677
}
678
679 a403fc03 Justin Ruggles
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 dc44d4ad Loren Merritt
    int i;
683 a403fc03 Justin Ruggles
    for(i=0; i<order; i++) {
684
        res[i] = smp[i];
685
    }
686 b250f9c6 Aurelien Jacobs
#if CONFIG_SMALL
687 f74471e0 Loren Merritt
    for(i=order; i<n; i+=2) {
688 dc44d4ad Loren Merritt
        int j;
689 b8de3429 Loren Merritt
        int s = smp[i];
690
        int p0 = 0, p1 = 0;
691
        for(j=0; j<order; j++) {
692
            int c = coefs[j];
693 f74471e0 Loren Merritt
            p1 += c*s;
694 b8de3429 Loren Merritt
            s = smp[i-j-1];
695
            p0 += c*s;
696 a403fc03 Justin Ruggles
        }
697 b8de3429 Loren Merritt
        res[i  ] = smp[i  ] - (p0 >> shift);
698 f74471e0 Loren Merritt
        res[i+1] = smp[i+1] - (p1 >> shift);
699 a403fc03 Justin Ruggles
    }
700 dc44d4ad Loren Merritt
#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 a403fc03 Justin Ruggles
}
714
715 e71bcc37 Justin Ruggles
static int encode_residual(FlacEncodeContext *ctx, int ch)
716
{
717 a403fc03 Justin Ruggles
    int i, n;
718 26053bdc Justin Ruggles
    int min_order, max_order, opt_order, precision, omethod;
719 1e5707b7 Justin Ruggles
    int min_porder, max_porder;
720 e71bcc37 Justin Ruggles
    FlacFrame *frame;
721
    FlacSubframe *sub;
722 a403fc03 Justin Ruggles
    int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
723
    int shift[MAX_LPC_ORDER];
724 e71bcc37 Justin Ruggles
    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 a403fc03 Justin Ruggles
    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 26053bdc Justin Ruggles
    omethod = ctx->options.prediction_order_method;
755 e71bcc37 Justin Ruggles
756
    /* FIXED */
757 a403fc03 Justin Ruggles
    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 1e5707b7 Justin Ruggles
            bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
765 a403fc03 Justin Ruggles
                                             n, i, sub->obits);
766
            if(bits[i] < bits[opt_order]) {
767
                opt_order = i;
768
            }
769 e71bcc37 Justin Ruggles
        }
770 a403fc03 Justin Ruggles
        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 1e5707b7 Justin Ruggles
            return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
776 a403fc03 Justin Ruggles
                                          sub->order, sub->obits);
777
        }
778
        return bits[sub->order];
779 e71bcc37 Justin Ruggles
    }
780 a403fc03 Justin Ruggles
781
    /* LPC */
782 9045f5e7 Justin Ruggles
    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 26053bdc Justin Ruggles
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 dbb45a3b Michael Niedermayer
    } 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 26053bdc Justin Ruggles
    }
842
843
    sub->order = opt_order;
844 a403fc03 Justin Ruggles
    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 e71bcc37 Justin Ruggles
    }
850 a403fc03 Justin Ruggles
    encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
851 1e5707b7 Justin Ruggles
    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
852 a403fc03 Justin Ruggles
                                sub->obits, precision);
853 e71bcc37 Justin Ruggles
}
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 f33aa120 Michael Niedermayer
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 e71bcc37 Justin Ruggles
    uint64_t sum[4];
889 f33aa120 Michael Niedermayer
    uint64_t score[4];
890 e71bcc37 Justin Ruggles
    int k;
891 f33aa120 Michael Niedermayer
892 a403fc03 Justin Ruggles
    /* calculate sum of 2nd order residual for each channel */
893 e71bcc37 Justin Ruggles
    sum[0] = sum[1] = sum[2] = sum[3] = 0;
894 f33aa120 Michael Niedermayer
    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 c26abfa5 Diego Biurrun
        sum[2] += FFABS((lt + rt) >> 1);
898
        sum[3] += FFABS(lt - rt);
899
        sum[0] += FFABS(lt);
900
        sum[1] += FFABS(rt);
901 e71bcc37 Justin Ruggles
    }
902 a403fc03 Justin Ruggles
    /* estimate bit counts */
903 e71bcc37 Justin Ruggles
    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 f33aa120 Michael Niedermayer
    }
907
908
    /* calculate score for each mode */
909 e71bcc37 Justin Ruggles
    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 f33aa120 Michael Niedermayer
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 3159780b Justin Ruggles
        return FLAC_CHMODE_INDEPENDENT;
923 f33aa120 Michael Niedermayer
    } 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 3159780b Justin Ruggles
        frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
948 f33aa120 Michael Niedermayer
        return;
949
    }
950
951
    frame->ch_mode = estimate_stereo_mode(left, right, n);
952
953
    /* perform decorrelation and adjust bits-per-sample */
954 3159780b Justin Ruggles
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
955 f33aa120 Michael Niedermayer
        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 e71bcc37 Justin Ruggles
static void write_utf8(PutBitContext *pb, uint32_t val)
979 9e96ab03 Michael Niedermayer
{
980 360932f7 Zuxy Meng
    uint8_t tmp;
981
    PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
982 9e96ab03 Michael Niedermayer
}
983
984 e71bcc37 Justin Ruggles
static void output_frame_header(FlacEncodeContext *s)
985 9e96ab03 Michael Niedermayer
{
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 3159780b Justin Ruggles
    if(frame->ch_mode == FLAC_CHMODE_INDEPENDENT) {
995 ad52941f Justin Ruggles
        put_bits(&s->pb, 4, s->channels-1);
996 9e96ab03 Michael Niedermayer
    } 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 f33aa120 Michael Niedermayer
    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 9e96ab03 Michael Niedermayer
    }
1007 f33aa120 Michael Niedermayer
    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 9e96ab03 Michael Niedermayer
    }
1012
    flush_put_bits(&s->pb);
1013 3abe5fbd Aurelien Jacobs
    crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
1014
                 s->pb.buf, put_bits_count(&s->pb)>>3);
1015 9e96ab03 Michael Niedermayer
    put_bits(&s->pb, 8, crc);
1016
}
1017
1018 e71bcc37 Justin Ruggles
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 9e96ab03 Michael Niedermayer
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 e71bcc37 Justin Ruggles
static void output_residual(FlacEncodeContext *ctx, int ch)
1045 9e96ab03 Michael Niedermayer
{
1046 e71bcc37 Justin Ruggles
    int i, j, p, n, parts;
1047 9e96ab03 Michael Niedermayer
    int k, porder, psize, res_cnt;
1048
    FlacFrame *frame;
1049
    FlacSubframe *sub;
1050 e71bcc37 Justin Ruggles
    int32_t *res;
1051 9e96ab03 Michael Niedermayer
1052
    frame = &ctx->frame;
1053
    sub = &frame->subframes[ch];
1054 e71bcc37 Justin Ruggles
    res = sub->residual;
1055
    n = frame->blocksize;
1056 9e96ab03 Michael Niedermayer
1057
    /* rice-encoded block */
1058
    put_bits(&ctx->pb, 2, 0);
1059
1060
    /* partition order */
1061 e71bcc37 Justin Ruggles
    porder = sub->rc.porder;
1062
    psize = n >> porder;
1063
    parts = (1 << porder);
1064 9e96ab03 Michael Niedermayer
    put_bits(&ctx->pb, 4, porder);
1065
    res_cnt = psize - sub->order;
1066
1067
    /* residual */
1068
    j = sub->order;
1069 e71bcc37 Justin Ruggles
    for(p=0; p<parts; p++) {
1070
        k = sub->rc.params[p];
1071 9e96ab03 Michael Niedermayer
        put_bits(&ctx->pb, 4, k);
1072
        if(p == 1) res_cnt = psize;
1073 e71bcc37 Justin Ruggles
        for(i=0; i<res_cnt && j<n; i++, j++) {
1074
            set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
1075 9e96ab03 Michael Niedermayer
        }
1076
    }
1077
}
1078
1079 e71bcc37 Justin Ruggles
static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
1080 9e96ab03 Michael Niedermayer
{
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 a403fc03 Justin Ruggles
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 9e96ab03 Michael Niedermayer
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 e71bcc37 Justin Ruggles
        if(sub->type == FLAC_SUBFRAME_CONSTANT) {
1141
            output_subframe_constant(s, ch);
1142
        } else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
1143 9e96ab03 Michael Niedermayer
            output_subframe_verbatim(s, ch);
1144 e71bcc37 Justin Ruggles
        } else if(sub->type == FLAC_SUBFRAME_FIXED) {
1145 9e96ab03 Michael Niedermayer
            output_subframe_fixed(s, ch);
1146 a403fc03 Justin Ruggles
        } else if(sub->type == FLAC_SUBFRAME_LPC) {
1147
            output_subframe_lpc(s, ch);
1148 9e96ab03 Michael Niedermayer
        }
1149
    }
1150
}
1151
1152
static void output_frame_footer(FlacEncodeContext *s)
1153
{
1154
    int crc;
1155
    flush_put_bits(&s->pb);
1156 3abe5fbd Aurelien Jacobs
    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 9e96ab03 Michael Niedermayer
    put_bits(&s->pb, 16, crc);
1159
    flush_put_bits(&s->pb);
1160
}
1161
1162 a9f8587e Justin Ruggles
static void update_md5_sum(FlacEncodeContext *s, int16_t *samples)
1163
{
1164 63613fe6 Måns Rullgård
#if HAVE_BIGENDIAN
1165 a9f8587e Justin Ruggles
    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 9e96ab03 Michael Niedermayer
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 f1f373c2 Justin Ruggles
    int reencoded=0;
1183 9e96ab03 Michael Niedermayer
1184
    s = avctx->priv_data;
1185
1186 f1f373c2 Justin Ruggles
    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 e1a12934 Justin Ruggles
    /* when the last block is reached, update the header in extradata */
1192
    if (!data) {
1193 6682ae42 Justin Ruggles
        s->max_framesize = s->max_encoded_framesize;
1194 a9f8587e Justin Ruggles
        av_md5_final(s->md5ctx, s->md5sum);
1195 e1a12934 Justin Ruggles
        write_streaminfo(s, avctx->extradata);
1196
        return 0;
1197
    }
1198
1199 f33aa120 Michael Niedermayer
    init_frame(s);
1200 9e96ab03 Michael Niedermayer
1201
    copy_samples(s, samples);
1202
1203 f33aa120 Michael Niedermayer
    channel_decorrelation(s);
1204
1205 9e96ab03 Michael Niedermayer
    for(ch=0; ch<s->channels; ch++) {
1206
        encode_residual(s, ch);
1207
    }
1208 f1f373c2 Justin Ruggles
1209
write_frame:
1210 9e96ab03 Michael Niedermayer
    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 f1f373c2 Justin Ruggles
    if(out_bytes > s->max_framesize) {
1217
        if(reencoded) {
1218 9e96ab03 Michael Niedermayer
            /* still too large. must be an error. */
1219
            av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
1220
            return -1;
1221
        }
1222 f1f373c2 Justin Ruggles
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 9e96ab03 Michael Niedermayer
    }
1230
1231
    s->frame_count++;
1232 e1a12934 Justin Ruggles
    s->sample_count += avctx->frame_size;
1233 a9f8587e Justin Ruggles
    update_md5_sum(s, samples);
1234 6682ae42 Justin Ruggles
    if (out_bytes > s->max_encoded_framesize)
1235
        s->max_encoded_framesize = out_bytes;
1236 b9b4fc5e Justin Ruggles
    if (out_bytes < s->min_framesize)
1237
        s->min_framesize = out_bytes;
1238 e1a12934 Justin Ruggles
1239 9e96ab03 Michael Niedermayer
    return out_bytes;
1240
}
1241
1242 98a6fff9 Zuxy Meng
static av_cold int flac_encode_close(AVCodecContext *avctx)
1243 9e96ab03 Michael Niedermayer
{
1244 a9f8587e Justin Ruggles
    if (avctx->priv_data) {
1245
        FlacEncodeContext *s = avctx->priv_data;
1246
        av_freep(&s->md5ctx);
1247
    }
1248 f33aa120 Michael Niedermayer
    av_freep(&avctx->extradata);
1249
    avctx->extradata_size = 0;
1250 9e96ab03 Michael Niedermayer
    av_freep(&avctx->coded_frame);
1251
    return 0;
1252
}
1253
1254
AVCodec flac_encoder = {
1255
    "flac",
1256 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_AUDIO,
1257 9e96ab03 Michael Niedermayer
    CODEC_ID_FLAC,
1258
    sizeof(FlacEncodeContext),
1259
    flac_encode_init,
1260
    flac_encode_frame,
1261
    flac_encode_close,
1262
    NULL,
1263 e1a12934 Justin Ruggles
    .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
1264 b5f09d31 Reimar Döffinger
    .sample_fmts = (const enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1265 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1266 9e96ab03 Michael Niedermayer
};