Mercurial > libavcodec.hg
annotate flacenc.c @ 12483:0159a19bfff7 libavcodec
aacdec: Rework channel mapping compatibility hacks.
For a PCE based configuration map the channels solely based on tags.
For an indexed configuration map the channels solely based on position.
This works with all known exotic samples including al17, elem_id0, bad_concat,
and lfe_is_sce.
author | alexc |
---|---|
date | Fri, 10 Sep 2010 18:01:48 +0000 |
parents | eeb078c8830a |
children |
rev | line source |
---|---|
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1 /** |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
2 * FLAC audio encoder |
7594
cd6217c9ce92
update my email address to one which does not depend on my service provider
jbr
parents:
7592
diff
changeset
|
3 * Copyright (c) 2006 Justin Ruggles <justin.ruggles@gmail.com> |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
4 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3481
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3481
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3481
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
8 * modify it under the terms of the GNU Lesser General Public |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
9 * License as published by the Free Software Foundation; either |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3481
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3481
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
15 * Lesser General Public License for more details. |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
16 * |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
17 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3481
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
20 */ |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
21 |
6763 | 22 #include "libavutil/crc.h" |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
23 #include "libavutil/md5.h" |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
24 #include "avcodec.h" |
9428 | 25 #include "get_bits.h" |
5737 | 26 #include "dsputil.h" |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
27 #include "golomb.h" |
7589
8b695a99e8df
flacenc, lpc: Move LPC code from flacenc.c to new lpc.[ch] files.
ramiro
parents:
7588
diff
changeset
|
28 #include "lpc.h" |
9188
f534d0cca450
share some constants between the FLAC encoder and FLAC decoder
jbr
parents:
8590
diff
changeset
|
29 #include "flac.h" |
9213
782d31263979
share sample rate and blocksize tables between the FLAC encoder and FLAC
jbr
parents:
9212
diff
changeset
|
30 #include "flacdata.h" |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
31 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
32 #define FLAC_SUBFRAME_CONSTANT 0 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
33 #define FLAC_SUBFRAME_VERBATIM 1 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
34 #define FLAC_SUBFRAME_FIXED 8 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
35 #define FLAC_SUBFRAME_LPC 32 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
36 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
37 #define MAX_FIXED_ORDER 4 |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
38 #define MAX_PARTITION_ORDER 8 |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
39 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER) |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
40 #define MAX_LPC_PRECISION 15 |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
41 #define MAX_LPC_SHIFT 15 |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
42 #define MAX_RICE_PARAM 14 |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
43 |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
44 typedef struct CompressionOptions { |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
45 int compression_level; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
46 int block_time_ms; |
12139
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
47 enum AVLPCType lpc_type; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
48 int lpc_passes; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
49 int lpc_coeff_precision; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
50 int min_prediction_order; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
51 int max_prediction_order; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
52 int prediction_order_method; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
53 int min_partition_order; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
54 int max_partition_order; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
55 } CompressionOptions; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
56 |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
57 typedef struct RiceContext { |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
58 int porder; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
59 int params[MAX_PARTITIONS]; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
60 } RiceContext; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
61 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
62 typedef struct FlacSubframe { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
63 int type; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
64 int type_code; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
65 int obits; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
66 int order; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
67 int32_t coefs[MAX_LPC_ORDER]; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
68 int shift; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
69 RiceContext rc; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
70 int32_t samples[FLAC_MAX_BLOCKSIZE]; |
5722 | 71 int32_t residual[FLAC_MAX_BLOCKSIZE+1]; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
72 } FlacSubframe; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
73 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
74 typedef struct FlacFrame { |
9188
f534d0cca450
share some constants between the FLAC encoder and FLAC decoder
jbr
parents:
8590
diff
changeset
|
75 FlacSubframe subframes[FLAC_MAX_CHANNELS]; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
76 int blocksize; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
77 int bs_code[2]; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
78 uint8_t crc8; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
79 int ch_mode; |
12321
b2940a8f3db6
Remove duplicate code by adding a flag for encoding in verbatim mode.
jbr
parents:
12319
diff
changeset
|
80 int verbatim_only; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
81 } FlacFrame; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
82 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
83 typedef struct FlacEncodeContext { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
84 PutBitContext pb; |
9214 | 85 int channels; |
86 int samplerate; | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
87 int sr_code[2]; |
9448
f2835afa516a
flacenc: write initial blocksize to STREAMINFO header instead of current
jbr
parents:
9432
diff
changeset
|
88 int max_blocksize; |
7864
4820bd751284
write actual min and max frame size to FLAC header. update regression test checksum.
jbr
parents:
7861
diff
changeset
|
89 int min_framesize; |
9214 | 90 int max_framesize; |
7864
4820bd751284
write actual min and max frame size to FLAC header. update regression test checksum.
jbr
parents:
7861
diff
changeset
|
91 int max_encoded_framesize; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
92 uint32_t frame_count; |
7860 | 93 uint64_t sample_count; |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
94 uint8_t md5sum[16]; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
95 FlacFrame frame; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
96 CompressionOptions options; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
97 AVCodecContext *avctx; |
5737 | 98 DSPContext dsp; |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
99 struct AVMD5 *md5ctx; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
100 } FlacEncodeContext; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
101 |
12300 | 102 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
103 /** |
12300 | 104 * Write streaminfo metadata block to byte array. |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
105 */ |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
106 static void write_streaminfo(FlacEncodeContext *s, uint8_t *header) |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
107 { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
108 PutBitContext pb; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
109 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
110 memset(header, 0, FLAC_STREAMINFO_SIZE); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
111 init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
112 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
113 /* streaminfo metadata block */ |
9448
f2835afa516a
flacenc: write initial blocksize to STREAMINFO header instead of current
jbr
parents:
9432
diff
changeset
|
114 put_bits(&pb, 16, s->max_blocksize); |
f2835afa516a
flacenc: write initial blocksize to STREAMINFO header instead of current
jbr
parents:
9432
diff
changeset
|
115 put_bits(&pb, 16, s->max_blocksize); |
7864
4820bd751284
write actual min and max frame size to FLAC header. update regression test checksum.
jbr
parents:
7861
diff
changeset
|
116 put_bits(&pb, 24, s->min_framesize); |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
117 put_bits(&pb, 24, s->max_framesize); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
118 put_bits(&pb, 20, s->samplerate); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
119 put_bits(&pb, 3, s->channels-1); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
120 put_bits(&pb, 5, 15); /* bits per sample - 1 */ |
7860 | 121 /* write 36-bit sample count in 2 put_bits() calls */ |
122 put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12); | |
123 put_bits(&pb, 12, s->sample_count & 0x000000FFFLL); | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
124 flush_put_bits(&pb); |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
125 memcpy(&header[18], s->md5sum, 16); |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
126 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
127 |
12300 | 128 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
129 /** |
12300 | 130 * Set blocksize based on samplerate. |
131 * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds. | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
132 */ |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
133 static int select_blocksize(int samplerate, int block_time_ms) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
134 { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
135 int i; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
136 int target; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
137 int blocksize; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
138 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
139 assert(samplerate > 0); |
9213
782d31263979
share sample rate and blocksize tables between the FLAC encoder and FLAC
jbr
parents:
9212
diff
changeset
|
140 blocksize = ff_flac_blocksize_table[1]; |
12300 | 141 target = (samplerate * block_time_ms) / 1000; |
142 for (i = 0; i < 16; i++) { | |
143 if (target >= ff_flac_blocksize_table[i] && | |
144 ff_flac_blocksize_table[i] > blocksize) { | |
9213
782d31263979
share sample rate and blocksize tables between the FLAC encoder and FLAC
jbr
parents:
9212
diff
changeset
|
145 blocksize = ff_flac_blocksize_table[i]; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
146 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
147 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
148 return blocksize; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
149 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
150 |
12300 | 151 |
12302
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
152 static av_cold void dprint_compression_options(FlacEncodeContext *s) |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
153 { |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
154 AVCodecContext *avctx = s->avctx; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
155 CompressionOptions *opt = &s->options; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
156 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
157 av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", opt->compression_level); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
158 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
159 switch (opt->lpc_type) { |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
160 case AV_LPC_TYPE_NONE: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
161 av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
162 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
163 case AV_LPC_TYPE_FIXED: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
164 av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed pre-defined coefficients\n"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
165 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
166 case AV_LPC_TYPE_LEVINSON: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
167 av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
168 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
169 case AV_LPC_TYPE_CHOLESKY: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
170 av_log(avctx, AV_LOG_DEBUG, " lpc type: Cholesky factorization, %d pass%s\n", |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
171 opt->lpc_passes, opt->lpc_passes == 1 ? "" : "es"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
172 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
173 } |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
174 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
175 av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n", |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
176 opt->min_prediction_order, opt->max_prediction_order); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
177 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
178 switch (opt->prediction_order_method) { |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
179 case ORDER_METHOD_EST: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
180 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "estimate"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
181 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
182 case ORDER_METHOD_2LEVEL: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
183 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "2-level"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
184 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
185 case ORDER_METHOD_4LEVEL: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
186 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "4-level"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
187 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
188 case ORDER_METHOD_8LEVEL: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
189 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "8-level"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
190 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
191 case ORDER_METHOD_SEARCH: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
192 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "full search"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
193 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
194 case ORDER_METHOD_LOG: |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
195 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "log search"); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
196 break; |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
197 } |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
198 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
199 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
200 av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n", |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
201 opt->min_partition_order, opt->max_partition_order); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
202 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
203 av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", avctx->frame_size); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
204 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
205 av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n", |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
206 opt->lpc_coeff_precision); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
207 } |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
208 |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
209 |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6341
diff
changeset
|
210 static av_cold int flac_encode_init(AVCodecContext *avctx) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
211 { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
212 int freq = avctx->sample_rate; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
213 int channels = avctx->channels; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
214 FlacEncodeContext *s = avctx->priv_data; |
3386 | 215 int i, level; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
216 uint8_t *streaminfo; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
217 |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
218 s->avctx = avctx; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
219 |
5737 | 220 dsputil_init(&s->dsp, avctx); |
221 | |
12300 | 222 if (avctx->sample_fmt != SAMPLE_FMT_S16) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
223 return -1; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
224 |
12300 | 225 if (channels < 1 || channels > FLAC_MAX_CHANNELS) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
226 return -1; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
227 s->channels = channels; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
228 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
229 /* find samplerate in table */ |
12300 | 230 if (freq < 1) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
231 return -1; |
12300 | 232 for (i = 4; i < 12; i++) { |
233 if (freq == ff_flac_sample_rate_table[i]) { | |
9213
782d31263979
share sample rate and blocksize tables between the FLAC encoder and FLAC
jbr
parents:
9212
diff
changeset
|
234 s->samplerate = ff_flac_sample_rate_table[i]; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
235 s->sr_code[0] = i; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
236 s->sr_code[1] = 0; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
237 break; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
238 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
239 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
240 /* if not in table, samplerate is non-standard */ |
12300 | 241 if (i == 12) { |
242 if (freq % 1000 == 0 && freq < 255000) { | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
243 s->sr_code[0] = 12; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
244 s->sr_code[1] = freq / 1000; |
12300 | 245 } else if (freq % 10 == 0 && freq < 655350) { |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
246 s->sr_code[0] = 14; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
247 s->sr_code[1] = freq / 10; |
12300 | 248 } else if (freq < 65535) { |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
249 s->sr_code[0] = 13; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
250 s->sr_code[1] = freq; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
251 } else { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
252 return -1; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
253 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
254 s->samplerate = freq; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
255 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
256 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
257 /* set compression option defaults based on avctx->compression_level */ |
12300 | 258 if (avctx->compression_level < 0) |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
259 s->options.compression_level = 5; |
12300 | 260 else |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
261 s->options.compression_level = avctx->compression_level; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
262 |
12300 | 263 level = s->options.compression_level; |
264 if (level > 12) { | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
265 av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
266 s->options.compression_level); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
267 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
268 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
269 |
12300 | 270 s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level]; |
271 | |
272 s->options.lpc_type = ((int[]){ AV_LPC_TYPE_FIXED, AV_LPC_TYPE_FIXED, AV_LPC_TYPE_FIXED, | |
273 AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, | |
274 AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, | |
275 AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, | |
276 AV_LPC_TYPE_LEVINSON})[level]; | |
277 | |
278 s->options.min_prediction_order = ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level]; | |
279 s->options.max_prediction_order = ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level]; | |
280 | |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
281 s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST, |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
282 ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST, |
3480
9eb59c4a22d2
Modify preset compression levels to utilize log search.
jbr
parents:
3478
diff
changeset
|
283 ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL, |
9eb59c4a22d2
Modify preset compression levels to utilize log search.
jbr
parents:
3478
diff
changeset
|
284 ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG, |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
285 ORDER_METHOD_SEARCH})[level]; |
12300 | 286 |
3481 | 287 s->options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level]; |
288 s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level]; | |
3386 | 289 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
290 /* set compression option overrides from AVCodecContext */ |
12139
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
291 #if LIBAVCODEC_VERSION_MAJOR < 53 |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
292 /* for compatibility with deprecated AVCodecContext.use_lpc */ |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
293 if (avctx->use_lpc == 0) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
294 s->options.lpc_type = AV_LPC_TYPE_FIXED; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
295 } else if (avctx->use_lpc == 1) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
296 s->options.lpc_type = AV_LPC_TYPE_LEVINSON; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
297 } else if (avctx->use_lpc > 1) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
298 s->options.lpc_type = AV_LPC_TYPE_CHOLESKY; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
299 s->options.lpc_passes = avctx->use_lpc - 1; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
300 } |
12139
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
301 #endif |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
302 if (avctx->lpc_type > AV_LPC_TYPE_DEFAULT) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
303 if (avctx->lpc_type > AV_LPC_TYPE_CHOLESKY) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
304 av_log(avctx, AV_LOG_ERROR, "unknown lpc type: %d\n", avctx->lpc_type); |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
305 return -1; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
306 } |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
307 s->options.lpc_type = avctx->lpc_type; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
308 if (s->options.lpc_type == AV_LPC_TYPE_CHOLESKY) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
309 if (avctx->lpc_passes < 0) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
310 // default number of passes for Cholesky |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
311 s->options.lpc_passes = 2; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
312 } else if (avctx->lpc_passes == 0) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
313 av_log(avctx, AV_LOG_ERROR, "invalid number of lpc passes: %d\n", |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
314 avctx->lpc_passes); |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
315 return -1; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
316 } else { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
317 s->options.lpc_passes = avctx->lpc_passes; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
318 } |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
319 } |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
320 } |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
321 |
12139
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
322 if (s->options.lpc_type == AV_LPC_TYPE_NONE) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
323 s->options.min_prediction_order = 0; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
324 } else if (avctx->min_prediction_order >= 0) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
325 if (s->options.lpc_type == AV_LPC_TYPE_FIXED) { |
12300 | 326 if (avctx->min_prediction_order > MAX_FIXED_ORDER) { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
327 av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
328 avctx->min_prediction_order); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
329 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
330 } |
12300 | 331 } else if (avctx->min_prediction_order < MIN_LPC_ORDER || |
332 avctx->min_prediction_order > MAX_LPC_ORDER) { | |
12139
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
333 av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
334 avctx->min_prediction_order); |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
335 return -1; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
336 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
337 s->options.min_prediction_order = avctx->min_prediction_order; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
338 } |
12139
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
339 if (s->options.lpc_type == AV_LPC_TYPE_NONE) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
340 s->options.max_prediction_order = 0; |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
341 } else if (avctx->max_prediction_order >= 0) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
342 if (s->options.lpc_type == AV_LPC_TYPE_FIXED) { |
12300 | 343 if (avctx->max_prediction_order > MAX_FIXED_ORDER) { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
344 av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
345 avctx->max_prediction_order); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
346 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
347 } |
12139
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
348 } else if (avctx->max_prediction_order < MIN_LPC_ORDER || |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
349 avctx->max_prediction_order > MAX_LPC_ORDER) { |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
350 av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
351 avctx->max_prediction_order); |
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
352 return -1; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
353 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
354 s->options.max_prediction_order = avctx->max_prediction_order; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
355 } |
12300 | 356 if (s->options.max_prediction_order < s->options.min_prediction_order) { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
357 av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
358 s->options.min_prediction_order, s->options.max_prediction_order); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
359 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
360 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
361 |
12300 | 362 if (avctx->prediction_order_method >= 0) { |
363 if (avctx->prediction_order_method > ORDER_METHOD_LOG) { | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
364 av_log(avctx, AV_LOG_ERROR, "invalid prediction order method: %d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
365 avctx->prediction_order_method); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
366 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
367 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
368 s->options.prediction_order_method = avctx->prediction_order_method; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
369 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
370 |
12300 | 371 if (avctx->min_partition_order >= 0) { |
372 if (avctx->min_partition_order > MAX_PARTITION_ORDER) { | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
373 av_log(avctx, AV_LOG_ERROR, "invalid min partition order: %d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
374 avctx->min_partition_order); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
375 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
376 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
377 s->options.min_partition_order = avctx->min_partition_order; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
378 } |
12300 | 379 if (avctx->max_partition_order >= 0) { |
380 if (avctx->max_partition_order > MAX_PARTITION_ORDER) { | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
381 av_log(avctx, AV_LOG_ERROR, "invalid max partition order: %d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
382 avctx->max_partition_order); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
383 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
384 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
385 s->options.max_partition_order = avctx->max_partition_order; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
386 } |
12300 | 387 if (s->options.max_partition_order < s->options.min_partition_order) { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
388 av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
389 s->options.min_partition_order, s->options.max_partition_order); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
390 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
391 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
392 |
12300 | 393 if (avctx->frame_size > 0) { |
394 if (avctx->frame_size < FLAC_MIN_BLOCKSIZE || | |
3442
5d133e59ecf2
allows user-settable block size and fixes related typo
jbr
parents:
3397
diff
changeset
|
395 avctx->frame_size > FLAC_MAX_BLOCKSIZE) { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
396 av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
397 avctx->frame_size); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
398 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
399 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
400 } else { |
6548 | 401 s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms); |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
402 } |
9448
f2835afa516a
flacenc: write initial blocksize to STREAMINFO header instead of current
jbr
parents:
9432
diff
changeset
|
403 s->max_blocksize = s->avctx->frame_size; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
404 |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
405 /* set LPC precision */ |
12300 | 406 if (avctx->lpc_coeff_precision > 0) { |
407 if (avctx->lpc_coeff_precision > MAX_LPC_PRECISION) { | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
408 av_log(avctx, AV_LOG_ERROR, "invalid lpc coeff precision: %d\n", |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
409 avctx->lpc_coeff_precision); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
410 return -1; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
411 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
412 s->options.lpc_coeff_precision = avctx->lpc_coeff_precision; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
413 } else { |
6545
85acd5166cf8
Use 15-bit LPC precision by default. This generally gives better compression
jbr
parents:
6517
diff
changeset
|
414 /* default LPC precision */ |
85acd5166cf8
Use 15-bit LPC precision by default. This generally gives better compression
jbr
parents:
6517
diff
changeset
|
415 s->options.lpc_coeff_precision = 15; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
416 } |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
417 |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
418 /* set maximum encoded frame size in verbatim mode */ |
9216
64246d9e583a
add a function to calculate a more accurate estimate for maximum FLAC
jbr
parents:
9214
diff
changeset
|
419 s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size, |
64246d9e583a
add a function to calculate a more accurate estimate for maximum FLAC
jbr
parents:
9214
diff
changeset
|
420 s->channels, 16); |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
421 |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
422 /* initialize MD5 context */ |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
423 s->md5ctx = av_malloc(av_md5_size); |
12300 | 424 if (!s->md5ctx) |
11581
998691d7f8f5
Replace all remaining occurrences of AVERROR_NOMEM with
stefano
parents:
11560
diff
changeset
|
425 return AVERROR(ENOMEM); |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
426 av_md5_init(s->md5ctx); |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
427 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
428 streaminfo = av_malloc(FLAC_STREAMINFO_SIZE); |
12301 | 429 if (!streaminfo) |
430 return AVERROR(ENOMEM); | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
431 write_streaminfo(s, streaminfo); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
432 avctx->extradata = streaminfo; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
433 avctx->extradata_size = FLAC_STREAMINFO_SIZE; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
434 |
12300 | 435 s->frame_count = 0; |
9212
c7a8e302b98a
flacenc: remove unneeded variable, 'min_encoded_framesize' and use
jbr
parents:
9209
diff
changeset
|
436 s->min_framesize = s->max_framesize; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
437 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
438 avctx->coded_frame = avcodec_alloc_frame(); |
12301 | 439 if (!avctx->coded_frame) |
440 return AVERROR(ENOMEM); | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
441 |
12302
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
442 dprint_compression_options(s); |
2e28769c55a9
Move debug logging of compression options to a single function.
jbr
parents:
12301
diff
changeset
|
443 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
444 return 0; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
445 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
446 |
12300 | 447 |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
448 static void init_frame(FlacEncodeContext *s) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
449 { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
450 int i, ch; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
451 FlacFrame *frame; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
452 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
453 frame = &s->frame; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
454 |
12300 | 455 for (i = 0; i < 16; i++) { |
456 if (s->avctx->frame_size == ff_flac_blocksize_table[i]) { | |
457 frame->blocksize = ff_flac_blocksize_table[i]; | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
458 frame->bs_code[0] = i; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
459 frame->bs_code[1] = 0; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
460 break; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
461 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
462 } |
12300 | 463 if (i == 16) { |
6548 | 464 frame->blocksize = s->avctx->frame_size; |
12300 | 465 if (frame->blocksize <= 256) { |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
466 frame->bs_code[0] = 6; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
467 frame->bs_code[1] = frame->blocksize-1; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
468 } else { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
469 frame->bs_code[0] = 7; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
470 frame->bs_code[1] = frame->blocksize-1; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
471 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
472 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
473 |
12300 | 474 for (ch = 0; ch < s->channels; ch++) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
475 frame->subframes[ch].obits = 16; |
12321
b2940a8f3db6
Remove duplicate code by adding a flag for encoding in verbatim mode.
jbr
parents:
12319
diff
changeset
|
476 |
b2940a8f3db6
Remove duplicate code by adding a flag for encoding in verbatim mode.
jbr
parents:
12319
diff
changeset
|
477 frame->verbatim_only = 0; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
478 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
479 |
12300 | 480 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
481 /** |
12300 | 482 * Copy channel-interleaved input samples into separate subframes. |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
483 */ |
12262
dde20597f15e
Use "const" qualifier for pointers that point to input data of
reimar
parents:
12139
diff
changeset
|
484 static void copy_samples(FlacEncodeContext *s, const int16_t *samples) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
485 { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
486 int i, j, ch; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
487 FlacFrame *frame; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
488 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
489 frame = &s->frame; |
12300 | 490 for (i = 0, j = 0; i < frame->blocksize; i++) |
491 for (ch = 0; ch < s->channels; ch++, j++) | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
492 frame->subframes[ch].samples[i] = samples[j]; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
493 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
494 |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
495 |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
496 static int rice_count_exact(int32_t *res, int n, int k) |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
497 { |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
498 int i; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
499 int count = 0; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
500 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
501 for (i = 0; i < n; i++) { |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
502 int32_t v = -2 * res[i] - 1; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
503 v ^= v >> 31; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
504 count += (v >> k) + 1 + k; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
505 } |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
506 return count; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
507 } |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
508 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
509 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
510 static int subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub, |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
511 int pred_order) |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
512 { |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
513 int p, porder, psize; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
514 int i, part_end; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
515 int count = 0; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
516 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
517 /* subframe header */ |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
518 count += 8; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
519 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
520 /* subframe */ |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
521 if (sub->type == FLAC_SUBFRAME_CONSTANT) { |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
522 count += sub->obits; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
523 } else if (sub->type == FLAC_SUBFRAME_VERBATIM) { |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
524 count += s->frame.blocksize * sub->obits; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
525 } else { |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
526 /* warm-up samples */ |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
527 count += pred_order * sub->obits; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
528 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
529 /* LPC coefficients */ |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
530 if (sub->type == FLAC_SUBFRAME_LPC) |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
531 count += 4 + 5 + pred_order * s->options.lpc_coeff_precision; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
532 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
533 /* rice-encoded block */ |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
534 count += 2; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
535 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
536 /* partition order */ |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
537 porder = sub->rc.porder; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
538 psize = s->frame.blocksize >> porder; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
539 count += 4; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
540 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
541 /* residual */ |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
542 i = pred_order; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
543 part_end = psize; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
544 for (p = 0; p < 1 << porder; p++) { |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
545 int k = sub->rc.params[p]; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
546 count += 4; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
547 count += rice_count_exact(&sub->residual[i], part_end - i, k); |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
548 i = part_end; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
549 part_end = FFMIN(s->frame.blocksize, part_end + psize); |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
550 } |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
551 } |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
552 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
553 return count; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
554 } |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
555 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
556 |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
557 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k))) |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
558 |
5732
d6fc148d1a48
replace brute force find_optimal_param() with a closed-form solution.
lorenm
parents:
5731
diff
changeset
|
559 /** |
12300 | 560 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0. |
5732
d6fc148d1a48
replace brute force find_optimal_param() with a closed-form solution.
lorenm
parents:
5731
diff
changeset
|
561 */ |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
562 static int find_optimal_param(uint32_t sum, int n) |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
563 { |
5732
d6fc148d1a48
replace brute force find_optimal_param() with a closed-form solution.
lorenm
parents:
5731
diff
changeset
|
564 int k; |
d6fc148d1a48
replace brute force find_optimal_param() with a closed-form solution.
lorenm
parents:
5731
diff
changeset
|
565 uint32_t sum2; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
566 |
12300 | 567 if (sum <= n >> 1) |
5732
d6fc148d1a48
replace brute force find_optimal_param() with a closed-form solution.
lorenm
parents:
5731
diff
changeset
|
568 return 0; |
12300 | 569 sum2 = sum - (n >> 1); |
570 k = av_log2(n < 256 ? FASTDIV(sum2, n) : sum2 / n); | |
5732
d6fc148d1a48
replace brute force find_optimal_param() with a closed-form solution.
lorenm
parents:
5731
diff
changeset
|
571 return FFMIN(k, MAX_RICE_PARAM); |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
572 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
573 |
12300 | 574 |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
575 static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder, |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
576 uint32_t *sums, int n, int pred_order) |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
577 { |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
578 int i; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
579 int k, cnt, part; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
580 uint32_t all_bits; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
581 |
12300 | 582 part = (1 << porder); |
5852 | 583 all_bits = 4 * part; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
584 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
585 cnt = (n >> porder) - pred_order; |
12300 | 586 for (i = 0; i < part; i++) { |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
587 k = find_optimal_param(sums[i], cnt); |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
588 rc->params[i] = k; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
589 all_bits += rice_encode_count(sums[i], cnt, k); |
5852 | 590 cnt = n >> porder; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
591 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
592 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
593 rc->porder = porder; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
594 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
595 return all_bits; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
596 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
597 |
12300 | 598 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
599 static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order, |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
600 uint32_t sums[][MAX_PARTITIONS]) |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
601 { |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
602 int i, j; |
3384 | 603 int parts; |
604 uint32_t *res, *res_end; | |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
605 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
606 /* sums for highest level */ |
12300 | 607 parts = (1 << pmax); |
608 res = &data[pred_order]; | |
3384 | 609 res_end = &data[n >> pmax]; |
12300 | 610 for (i = 0; i < parts; i++) { |
5731
976b4c5e68bb
gcc isn't smart enough to factor out duplicate stores
lorenm
parents:
5729
diff
changeset
|
611 uint32_t sum = 0; |
12300 | 612 while (res < res_end) |
5731
976b4c5e68bb
gcc isn't smart enough to factor out duplicate stores
lorenm
parents:
5729
diff
changeset
|
613 sum += *(res++); |
976b4c5e68bb
gcc isn't smart enough to factor out duplicate stores
lorenm
parents:
5729
diff
changeset
|
614 sums[pmax][i] = sum; |
12300 | 615 res_end += n >> pmax; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
616 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
617 /* sums for lower levels */ |
12300 | 618 for (i = pmax - 1; i >= pmin; i--) { |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
619 parts = (1 << i); |
12300 | 620 for (j = 0; j < parts; j++) |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
621 sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1]; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
622 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
623 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
624 |
12300 | 625 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
626 static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax, |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
627 int32_t *data, int n, int pred_order) |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
628 { |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
629 int i; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
630 uint32_t bits[MAX_PARTITION_ORDER+1]; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
631 int opt_porder; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
632 RiceContext tmp_rc; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
633 uint32_t *udata; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
634 uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS]; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
635 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
636 assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
637 assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER); |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
638 assert(pmin <= pmax); |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
639 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
640 udata = av_malloc(n * sizeof(uint32_t)); |
12300 | 641 for (i = 0; i < n; i++) |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
642 udata[i] = (2*data[i]) ^ (data[i]>>31); |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
643 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
644 calc_sums(pmin, pmax, udata, n, pred_order, sums); |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
645 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
646 opt_porder = pmin; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
647 bits[pmin] = UINT32_MAX; |
12300 | 648 for (i = pmin; i <= pmax; i++) { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
649 bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order); |
12300 | 650 if (bits[i] <= bits[opt_porder]) { |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
651 opt_porder = i; |
12300 | 652 *rc = tmp_rc; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
653 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
654 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
655 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
656 av_freep(&udata); |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
657 return bits[opt_porder]; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
658 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
659 |
12300 | 660 |
3397
bdfc530c417c
porder patch by (Justin Ruggles jruggle a t earthlink d ot net)
michael
parents:
3390
diff
changeset
|
661 static int get_max_p_order(int max_porder, int n, int order) |
bdfc530c417c
porder patch by (Justin Ruggles jruggle a t earthlink d ot net)
michael
parents:
3390
diff
changeset
|
662 { |
bdfc530c417c
porder patch by (Justin Ruggles jruggle a t earthlink d ot net)
michael
parents:
3390
diff
changeset
|
663 int porder = FFMIN(max_porder, av_log2(n^(n-1))); |
12300 | 664 if (order > 0) |
3397
bdfc530c417c
porder patch by (Justin Ruggles jruggle a t earthlink d ot net)
michael
parents:
3390
diff
changeset
|
665 porder = FFMIN(porder, av_log2(n/order)); |
bdfc530c417c
porder patch by (Justin Ruggles jruggle a t earthlink d ot net)
michael
parents:
3390
diff
changeset
|
666 return porder; |
bdfc530c417c
porder patch by (Justin Ruggles jruggle a t earthlink d ot net)
michael
parents:
3390
diff
changeset
|
667 } |
bdfc530c417c
porder patch by (Justin Ruggles jruggle a t earthlink d ot net)
michael
parents:
3390
diff
changeset
|
668 |
12300 | 669 |
12328
6b57b1b2095c
cosmetics: rename find_subblock_rice_params() to find_subframe_rice_params()
jbr
parents:
12327
diff
changeset
|
670 static uint32_t find_subframe_rice_params(FlacEncodeContext *s, |
12327
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
671 FlacSubframe *sub, int pred_order) |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
672 { |
12327
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
673 int pmin = get_max_p_order(s->options.min_partition_order, |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
674 s->frame.blocksize, pred_order); |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
675 int pmax = get_max_p_order(s->options.max_partition_order, |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
676 s->frame.blocksize, pred_order); |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
677 |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
678 uint32_t bits = 8 + pred_order * sub->obits + 2 + 4; |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
679 if (sub->type == FLAC_SUBFRAME_LPC) |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
680 bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision; |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
681 bits += calc_rice_params(&sub->rc, pmin, pmax, sub->residual, |
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
682 s->frame.blocksize, pred_order); |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
683 return bits; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
684 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
685 |
12300 | 686 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
687 static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
688 int order) |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
689 { |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
690 int i; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
691 |
12300 | 692 for (i = 0; i < order; i++) |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
693 res[i] = smp[i]; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
694 |
12300 | 695 if (order == 0) { |
696 for (i = order; i < n; i++) | |
697 res[i] = smp[i]; | |
698 } else if (order == 1) { | |
699 for (i = order; i < n; i++) | |
700 res[i] = smp[i] - smp[i-1]; | |
701 } else if (order == 2) { | |
5738
c1a4aae5adb4
encode_residual_fixed(): replace FIR with finite differences.
lorenm
parents:
5737
diff
changeset
|
702 int a = smp[order-1] - smp[order-2]; |
12300 | 703 for (i = order; i < n; i += 2) { |
704 int b = smp[i ] - smp[i-1]; | |
705 res[i] = b - a; | |
706 a = smp[i+1] - smp[i ]; | |
707 res[i+1] = a - b; | |
5738
c1a4aae5adb4
encode_residual_fixed(): replace FIR with finite differences.
lorenm
parents:
5737
diff
changeset
|
708 } |
12300 | 709 } else if (order == 3) { |
710 int a = smp[order-1] - smp[order-2]; | |
5738
c1a4aae5adb4
encode_residual_fixed(): replace FIR with finite differences.
lorenm
parents:
5737
diff
changeset
|
711 int c = smp[order-1] - 2*smp[order-2] + smp[order-3]; |
12300 | 712 for (i = order; i < n; i += 2) { |
713 int b = smp[i ] - smp[i-1]; | |
714 int d = b - a; | |
715 res[i] = d - c; | |
716 a = smp[i+1] - smp[i ]; | |
717 c = a - b; | |
718 res[i+1] = c - d; | |
5738
c1a4aae5adb4
encode_residual_fixed(): replace FIR with finite differences.
lorenm
parents:
5737
diff
changeset
|
719 } |
12300 | 720 } else { |
721 int a = smp[order-1] - smp[order-2]; | |
722 int c = smp[order-1] - 2*smp[order-2] + smp[order-3]; | |
5738
c1a4aae5adb4
encode_residual_fixed(): replace FIR with finite differences.
lorenm
parents:
5737
diff
changeset
|
723 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4]; |
12300 | 724 for (i = order; i < n; i += 2) { |
725 int b = smp[i ] - smp[i-1]; | |
726 int d = b - a; | |
727 int f = d - c; | |
728 res[i ] = f - e; | |
729 a = smp[i+1] - smp[i ]; | |
730 c = a - b; | |
731 e = c - d; | |
732 res[i+1] = e - f; | |
5738
c1a4aae5adb4
encode_residual_fixed(): replace FIR with finite differences.
lorenm
parents:
5737
diff
changeset
|
733 } |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
734 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
735 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
736 |
12300 | 737 |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
738 #define LPC1(x) {\ |
5742 | 739 int c = coefs[(x)-1];\ |
12300 | 740 p0 += c * s;\ |
741 s = smp[i-(x)+1];\ | |
742 p1 += c * s;\ | |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
743 } |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
744 |
12300 | 745 static av_always_inline void encode_residual_lpc_unrolled(int32_t *res, |
746 const int32_t *smp, int n, int order, | |
747 const int32_t *coefs, int shift, int big) | |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
748 { |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
749 int i; |
12300 | 750 for (i = order; i < n; i += 2) { |
751 int s = smp[i-order]; | |
5742 | 752 int p0 = 0, p1 = 0; |
12300 | 753 if (big) { |
754 switch (order) { | |
755 case 32: LPC1(32) | |
756 case 31: LPC1(31) | |
757 case 30: LPC1(30) | |
758 case 29: LPC1(29) | |
759 case 28: LPC1(28) | |
760 case 27: LPC1(27) | |
761 case 26: LPC1(26) | |
762 case 25: LPC1(25) | |
763 case 24: LPC1(24) | |
764 case 23: LPC1(23) | |
765 case 22: LPC1(22) | |
766 case 21: LPC1(21) | |
767 case 20: LPC1(20) | |
768 case 19: LPC1(19) | |
769 case 18: LPC1(18) | |
770 case 17: LPC1(17) | |
771 case 16: LPC1(16) | |
772 case 15: LPC1(15) | |
773 case 14: LPC1(14) | |
774 case 13: LPC1(13) | |
775 case 12: LPC1(12) | |
776 case 11: LPC1(11) | |
777 case 10: LPC1(10) | |
778 case 9: LPC1( 9) | |
779 LPC1( 8) | |
780 LPC1( 7) | |
781 LPC1( 6) | |
782 LPC1( 5) | |
783 LPC1( 4) | |
784 LPC1( 3) | |
785 LPC1( 2) | |
786 LPC1( 1) | |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
787 } |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
788 } else { |
12300 | 789 switch (order) { |
790 case 8: LPC1( 8) | |
791 case 7: LPC1( 7) | |
792 case 6: LPC1( 6) | |
793 case 5: LPC1( 5) | |
794 case 4: LPC1( 4) | |
795 case 3: LPC1( 3) | |
796 case 2: LPC1( 2) | |
797 case 1: LPC1( 1) | |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
798 } |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
799 } |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
800 res[i ] = smp[i ] - (p0 >> shift); |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
801 res[i+1] = smp[i+1] - (p1 >> shift); |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
802 } |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
803 } |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
804 |
12300 | 805 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
806 static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n, |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
807 int order, const int32_t *coefs, int shift) |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
808 { |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
809 int i; |
12300 | 810 for (i = 0; i < order; i++) |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
811 res[i] = smp[i]; |
8590 | 812 #if CONFIG_SMALL |
12300 | 813 for (i = order; i < n; i += 2) { |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
814 int j; |
12300 | 815 int s = smp[i]; |
5742 | 816 int p0 = 0, p1 = 0; |
12300 | 817 for (j = 0; j < order; j++) { |
5742 | 818 int c = coefs[j]; |
12300 | 819 p1 += c * s; |
820 s = smp[i-j-1]; | |
821 p0 += c * s; | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
822 } |
5742 | 823 res[i ] = smp[i ] - (p0 >> shift); |
5720 | 824 res[i+1] = smp[i+1] - (p1 >> shift); |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
825 } |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
826 #else |
12300 | 827 switch (order) { |
828 case 1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break; | |
829 case 2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break; | |
830 case 3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break; | |
831 case 4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break; | |
832 case 5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break; | |
833 case 6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break; | |
834 case 7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break; | |
835 case 8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break; | |
836 default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break; | |
5724
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
837 } |
96d1b6c30aad
unroll encode_residual_lpc(). speedup varies between 1.2x and 1.8x depending on lpc order.
lorenm
parents:
5722
diff
changeset
|
838 #endif |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
839 } |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
840 |
12300 | 841 |
12319 | 842 static int encode_residual_ch(FlacEncodeContext *s, int ch) |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
843 { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
844 int i, n; |
12327
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
845 int min_order, max_order, opt_order, omethod; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
846 FlacFrame *frame; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
847 FlacSubframe *sub; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
848 int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
849 int shift[MAX_LPC_ORDER]; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
850 int32_t *res, *smp; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
851 |
12305
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
852 frame = &s->frame; |
12300 | 853 sub = &frame->subframes[ch]; |
854 res = sub->residual; | |
855 smp = sub->samples; | |
856 n = frame->blocksize; | |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
857 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
858 /* CONSTANT */ |
12300 | 859 for (i = 1; i < n; i++) |
860 if(smp[i] != smp[0]) | |
861 break; | |
862 if (i == n) { | |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
863 sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
864 res[0] = smp[0]; |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
865 return subframe_count_exact(s, sub, 0); |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
866 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
867 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
868 /* VERBATIM */ |
12321
b2940a8f3db6
Remove duplicate code by adding a flag for encoding in verbatim mode.
jbr
parents:
12319
diff
changeset
|
869 if (frame->verbatim_only || n < 5) { |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
870 sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM; |
12322 | 871 memcpy(res, smp, n * sizeof(int32_t)); |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
872 return subframe_count_exact(s, sub, 0); |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
873 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
874 |
12305
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
875 min_order = s->options.min_prediction_order; |
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
876 max_order = s->options.max_prediction_order; |
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
877 omethod = s->options.prediction_order_method; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
878 |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
879 /* FIXED */ |
12327
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
880 sub->type = FLAC_SUBFRAME_FIXED; |
12305
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
881 if (s->options.lpc_type == AV_LPC_TYPE_NONE || |
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
882 s->options.lpc_type == AV_LPC_TYPE_FIXED || n <= max_order) { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
883 uint32_t bits[MAX_FIXED_ORDER+1]; |
12300 | 884 if (max_order > MAX_FIXED_ORDER) |
885 max_order = MAX_FIXED_ORDER; | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
886 opt_order = 0; |
12300 | 887 bits[0] = UINT32_MAX; |
888 for (i = min_order; i <= max_order; i++) { | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
889 encode_residual_fixed(res, smp, n, i); |
12328
6b57b1b2095c
cosmetics: rename find_subblock_rice_params() to find_subframe_rice_params()
jbr
parents:
12327
diff
changeset
|
890 bits[i] = find_subframe_rice_params(s, sub, i); |
12300 | 891 if (bits[i] < bits[opt_order]) |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
892 opt_order = i; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
893 } |
12300 | 894 sub->order = opt_order; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
895 sub->type_code = sub->type | sub->order; |
12300 | 896 if (sub->order != max_order) { |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
897 encode_residual_fixed(res, smp, n, sub->order); |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
898 find_subframe_rice_params(s, sub, sub->order); |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
899 } |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
900 return subframe_count_exact(s, sub, sub->order); |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
901 } |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
902 |
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
903 /* LPC */ |
12327
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
904 sub->type = FLAC_SUBFRAME_LPC; |
12305
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
905 opt_order = ff_lpc_calc_coefs(&s->dsp, smp, n, min_order, max_order, |
12327
dd8053936c33
Reduce number of input parameters to find_subblock_rice_params().
jbr
parents:
12326
diff
changeset
|
906 s->options.lpc_coeff_precision, coefs, shift, s->options.lpc_type, |
12305
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
907 s->options.lpc_passes, omethod, |
12139
e59926e2c50c
Add AVCodecContext.lpc_type and Add AVCodecContext.lpc_passes fields.
jbr
parents:
12129
diff
changeset
|
908 MAX_LPC_SHIFT, 0); |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
909 |
12300 | 910 if (omethod == ORDER_METHOD_2LEVEL || |
911 omethod == ORDER_METHOD_4LEVEL || | |
912 omethod == ORDER_METHOD_8LEVEL) { | |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
913 int levels = 1 << omethod; |
11936 | 914 uint32_t bits[1 << ORDER_METHOD_8LEVEL]; |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
915 int order; |
12300 | 916 int opt_index = levels-1; |
917 opt_order = max_order-1; | |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
918 bits[opt_index] = UINT32_MAX; |
12300 | 919 for (i = levels-1; i >= 0; i--) { |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
920 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1; |
12300 | 921 if (order < 0) |
922 order = 0; | |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
923 encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]); |
12328
6b57b1b2095c
cosmetics: rename find_subblock_rice_params() to find_subframe_rice_params()
jbr
parents:
12327
diff
changeset
|
924 bits[i] = find_subframe_rice_params(s, sub, order+1); |
12300 | 925 if (bits[i] < bits[opt_index]) { |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
926 opt_index = i; |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
927 opt_order = order; |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
928 } |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
929 } |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
930 opt_order++; |
12300 | 931 } else if (omethod == ORDER_METHOD_SEARCH) { |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
932 // brute-force optimal order search |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
933 uint32_t bits[MAX_LPC_ORDER]; |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
934 opt_order = 0; |
12300 | 935 bits[0] = UINT32_MAX; |
936 for (i = min_order-1; i < max_order; i++) { | |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
937 encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]); |
12328
6b57b1b2095c
cosmetics: rename find_subblock_rice_params() to find_subframe_rice_params()
jbr
parents:
12327
diff
changeset
|
938 bits[i] = find_subframe_rice_params(s, sub, i+1); |
12300 | 939 if (bits[i] < bits[opt_order]) |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
940 opt_order = i; |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
941 } |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
942 opt_order++; |
12300 | 943 } else if (omethod == ORDER_METHOD_LOG) { |
3478 | 944 uint32_t bits[MAX_LPC_ORDER]; |
945 int step; | |
946 | |
12300 | 947 opt_order = min_order - 1 + (max_order-min_order)/3; |
3478 | 948 memset(bits, -1, sizeof(bits)); |
949 | |
12300 | 950 for (step = 16; step; step >>= 1) { |
951 int last = opt_order; | |
952 for (i = last-step; i <= last+step; i += step) { | |
953 if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX) | |
3478 | 954 continue; |
955 encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]); | |
12328
6b57b1b2095c
cosmetics: rename find_subblock_rice_params() to find_subframe_rice_params()
jbr
parents:
12327
diff
changeset
|
956 bits[i] = find_subframe_rice_params(s, sub, i+1); |
12300 | 957 if (bits[i] < bits[opt_order]) |
958 opt_order = i; | |
3478 | 959 } |
960 } | |
961 opt_order++; | |
3477
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
962 } |
30ac8a424448
Add lpc order search. This creates new compression levels 6 to 12.
jbr
parents:
3473
diff
changeset
|
963 |
12300 | 964 sub->order = opt_order; |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
965 sub->type_code = sub->type | (sub->order-1); |
12300 | 966 sub->shift = shift[sub->order-1]; |
967 for (i = 0; i < sub->order; i++) | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
968 sub->coefs[i] = coefs[sub->order-1][i]; |
12300 | 969 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
970 encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift); |
12300 | 971 |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
972 find_subframe_rice_params(s, sub, sub->order); |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
973 |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
974 return subframe_count_exact(s, sub, sub->order); |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
975 } |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
976 |
12300 | 977 |
12319 | 978 static int count_frame_header(FlacEncodeContext *s) |
979 { | |
980 uint8_t tmp; | |
981 int count; | |
982 | |
983 /* | |
984 <14> Sync code | |
985 <1> Reserved | |
986 <1> Blocking strategy | |
987 <4> Block size in inter-channel samples | |
988 <4> Sample rate | |
989 <4> Channel assignment | |
990 <3> Sample size in bits | |
991 <1> Reserved | |
992 */ | |
993 count = 32; | |
994 | |
995 /* coded frame number */ | |
996 PUT_UTF8(s->frame_count, tmp, count += 8;) | |
997 | |
998 /* explicit block size */ | |
12326 | 999 if (s->frame.bs_code[0] == 6) |
1000 count += 8; | |
1001 else if (s->frame.bs_code[0] == 7) | |
1002 count += 16; | |
12319 | 1003 |
1004 /* explicit sample rate */ | |
1005 count += ((s->sr_code[0] == 12) + (s->sr_code[0] > 12)) * 8; | |
1006 | |
1007 /* frame header CRC-8 */ | |
1008 count += 8; | |
1009 | |
1010 return count; | |
1011 } | |
1012 | |
1013 | |
1014 static int encode_frame(FlacEncodeContext *s) | |
1015 { | |
1016 int ch, count; | |
1017 | |
1018 count = count_frame_header(s); | |
1019 | |
1020 for (ch = 0; ch < s->channels; ch++) | |
1021 count += encode_residual_ch(s, ch); | |
1022 | |
1023 count += (8 - (count & 7)) & 7; // byte alignment | |
1024 count += 16; // CRC-16 | |
1025 | |
1026 return count >> 3; | |
1027 } | |
1028 | |
1029 | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1030 static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n) |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1031 { |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1032 int i, best; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1033 int32_t lt, rt; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1034 uint64_t sum[4]; |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1035 uint64_t score[4]; |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1036 int k; |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1037 |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
1038 /* calculate sum of 2nd order residual for each channel */ |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1039 sum[0] = sum[1] = sum[2] = sum[3] = 0; |
12300 | 1040 for (i = 2; i < n; i++) { |
1041 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2]; | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1042 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2]; |
4001 | 1043 sum[2] += FFABS((lt + rt) >> 1); |
1044 sum[3] += FFABS(lt - rt); | |
1045 sum[0] += FFABS(lt); | |
1046 sum[1] += FFABS(rt); | |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1047 } |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
1048 /* estimate bit counts */ |
12300 | 1049 for (i = 0; i < 4; i++) { |
1050 k = find_optimal_param(2 * sum[i], n); | |
1051 sum[i] = rice_encode_count( 2 * sum[i], n, k); | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1052 } |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1053 |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1054 /* calculate score for each mode */ |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1055 score[0] = sum[0] + sum[1]; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1056 score[1] = sum[0] + sum[3]; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1057 score[2] = sum[1] + sum[3]; |
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1058 score[3] = sum[2] + sum[3]; |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1059 |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1060 /* return mode with lowest score */ |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1061 best = 0; |
12300 | 1062 for (i = 1; i < 4; i++) |
1063 if (score[i] < score[best]) | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1064 best = i; |
12300 | 1065 if (best == 0) { |
9208
443f056ba7e7
share channel mode constants between the FLAC decoder and FLAC encoder
jbr
parents:
9188
diff
changeset
|
1066 return FLAC_CHMODE_INDEPENDENT; |
12300 | 1067 } else if (best == 1) { |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1068 return FLAC_CHMODE_LEFT_SIDE; |
12300 | 1069 } else if (best == 2) { |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1070 return FLAC_CHMODE_RIGHT_SIDE; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1071 } else { |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1072 return FLAC_CHMODE_MID_SIDE; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1073 } |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1074 } |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1075 |
12300 | 1076 |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1077 /** |
12300 | 1078 * Perform stereo channel decorrelation. |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1079 */ |
12305
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
1080 static void channel_decorrelation(FlacEncodeContext *s) |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1081 { |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1082 FlacFrame *frame; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1083 int32_t *left, *right; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1084 int i, n; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1085 |
12305
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
1086 frame = &s->frame; |
12300 | 1087 n = frame->blocksize; |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1088 left = frame->subframes[0].samples; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1089 right = frame->subframes[1].samples; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1090 |
12305
000218dd70aa
cosmetics: change FlacEncodeContext variable name from ctx to s in several
jbr
parents:
12304
diff
changeset
|
1091 if (s->channels != 2) { |
9208
443f056ba7e7
share channel mode constants between the FLAC decoder and FLAC encoder
jbr
parents:
9188
diff
changeset
|
1092 frame->ch_mode = FLAC_CHMODE_INDEPENDENT; |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1093 return; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1094 } |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1095 |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1096 frame->ch_mode = estimate_stereo_mode(left, right, n); |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1097 |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1098 /* perform decorrelation and adjust bits-per-sample */ |
12300 | 1099 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT) |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1100 return; |
12300 | 1101 if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) { |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1102 int32_t tmp; |
12300 | 1103 for (i = 0; i < n; i++) { |
1104 tmp = left[i]; | |
1105 left[i] = (tmp + right[i]) >> 1; | |
1106 right[i] = tmp - right[i]; | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1107 } |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1108 frame->subframes[1].obits++; |
12300 | 1109 } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) { |
1110 for (i = 0; i < n; i++) | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1111 right[i] = left[i] - right[i]; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1112 frame->subframes[1].obits++; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1113 } else { |
12300 | 1114 for (i = 0; i < n; i++) |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1115 left[i] -= right[i]; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1116 frame->subframes[0].obits++; |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1117 } |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1118 } |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1119 |
12300 | 1120 |
3365
84f29207af3a
flacenc - rice param search patch by (Justin Ruggles jruggle earthlink net
michael
parents:
3358
diff
changeset
|
1121 static void write_utf8(PutBitContext *pb, uint32_t val) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1122 { |
4149
3118e8afb8a5
Fix ASF format parser's broken UTF-16 string handling
gpoirier
parents:
4001
diff
changeset
|
1123 uint8_t tmp; |
3118e8afb8a5
Fix ASF format parser's broken UTF-16 string handling
gpoirier
parents:
4001
diff
changeset
|
1124 PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1125 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1126 |
12300 | 1127 |
12332 | 1128 static void write_frame_header(FlacEncodeContext *s) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1129 { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1130 FlacFrame *frame; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1131 int crc; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1132 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1133 frame = &s->frame; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1134 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1135 put_bits(&s->pb, 16, 0xFFF8); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1136 put_bits(&s->pb, 4, frame->bs_code[0]); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1137 put_bits(&s->pb, 4, s->sr_code[0]); |
12300 | 1138 |
1139 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT) | |
9209 | 1140 put_bits(&s->pb, 4, s->channels-1); |
12300 | 1141 else |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1142 put_bits(&s->pb, 4, frame->ch_mode); |
12300 | 1143 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1144 put_bits(&s->pb, 3, 4); /* bits-per-sample code */ |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1145 put_bits(&s->pb, 1, 0); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1146 write_utf8(&s->pb, s->frame_count); |
12300 | 1147 |
1148 if (frame->bs_code[0] == 6) | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1149 put_bits(&s->pb, 8, frame->bs_code[1]); |
12300 | 1150 else if (frame->bs_code[0] == 7) |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1151 put_bits(&s->pb, 16, frame->bs_code[1]); |
12300 | 1152 |
1153 if (s->sr_code[0] == 12) | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1154 put_bits(&s->pb, 8, s->sr_code[1]); |
12300 | 1155 else if (s->sr_code[0] > 12) |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1156 put_bits(&s->pb, 16, s->sr_code[1]); |
12300 | 1157 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1158 flush_put_bits(&s->pb); |
12300 | 1159 crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s->pb.buf, |
1160 put_bits_count(&s->pb) >> 3); | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1161 put_bits(&s->pb, 8, crc); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1162 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1163 |
12300 | 1164 |
12332 | 1165 static void write_subframes(FlacEncodeContext *s) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1166 { |
12314 | 1167 int ch; |
1168 | |
1169 for (ch = 0; ch < s->channels; ch++) { | |
1170 FlacSubframe *sub = &s->frame.subframes[ch]; | |
12315 | 1171 int i, p, porder, psize; |
1172 int32_t *part_end; | |
1173 int32_t *res = sub->residual; | |
1174 int32_t *frame_end = &sub->residual[s->frame.blocksize]; | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1175 |
12314 | 1176 /* subframe header */ |
1177 put_bits(&s->pb, 1, 0); | |
1178 put_bits(&s->pb, 6, sub->type_code); | |
1179 put_bits(&s->pb, 1, 0); /* no wasted bits */ | |
1180 | |
1181 /* subframe */ | |
12315 | 1182 if (sub->type == FLAC_SUBFRAME_CONSTANT) { |
1183 put_sbits(&s->pb, sub->obits, res[0]); | |
1184 } else if (sub->type == FLAC_SUBFRAME_VERBATIM) { | |
1185 while (res < frame_end) | |
1186 put_sbits(&s->pb, sub->obits, *res++); | |
1187 } else { | |
1188 /* warm-up samples */ | |
1189 for (i = 0; i < sub->order; i++) | |
1190 put_sbits(&s->pb, sub->obits, *res++); | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1191 |
12315 | 1192 /* LPC coefficients */ |
1193 if (sub->type == FLAC_SUBFRAME_LPC) { | |
1194 int cbits = s->options.lpc_coeff_precision; | |
1195 put_bits( &s->pb, 4, cbits-1); | |
1196 put_sbits(&s->pb, 5, sub->shift); | |
1197 for (i = 0; i < sub->order; i++) | |
1198 put_sbits(&s->pb, cbits, sub->coefs[i]); | |
1199 } | |
3385
340e5d35b326
flac-lpc patch by (Justin Ruggles jruggle earthlink net)
michael
parents:
3384
diff
changeset
|
1200 |
12315 | 1201 /* rice-encoded block */ |
1202 put_bits(&s->pb, 2, 0); | |
12310
eba0e28f6dbc
Combine and simplify output_residual() and output_subframe_lpc().
jbr
parents:
12309
diff
changeset
|
1203 |
12315 | 1204 /* partition order */ |
1205 porder = sub->rc.porder; | |
1206 psize = s->frame.blocksize >> porder; | |
1207 put_bits(&s->pb, 4, porder); | |
12310
eba0e28f6dbc
Combine and simplify output_residual() and output_subframe_lpc().
jbr
parents:
12309
diff
changeset
|
1208 |
12315 | 1209 /* residual */ |
1210 part_end = &sub->residual[psize]; | |
1211 for (p = 0; p < 1 << porder; p++) { | |
1212 int k = sub->rc.params[p]; | |
1213 put_bits(&s->pb, 4, k); | |
1214 while (res < part_end) | |
1215 set_sr_golomb_flac(&s->pb, *res++, k, INT32_MAX, 0); | |
1216 part_end = FFMIN(frame_end, part_end + psize); | |
1217 } | |
12312 | 1218 } |
12311
1a4351501522
Combine output_subframe_verbatim() and output_subframe_lpc().
jbr
parents:
12310
diff
changeset
|
1219 } |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1220 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1221 |
12300 | 1222 |
12332 | 1223 static void write_frame_footer(FlacEncodeContext *s) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1224 { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1225 int crc; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1226 flush_put_bits(&s->pb); |
12300 | 1227 crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s->pb.buf, |
1228 put_bits_count(&s->pb)>>3)); | |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1229 put_bits(&s->pb, 16, crc); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1230 flush_put_bits(&s->pb); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1231 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1232 |
12300 | 1233 |
12325 | 1234 static int write_frame(FlacEncodeContext *s, uint8_t *frame, int buf_size) |
1235 { | |
1236 init_put_bits(&s->pb, frame, buf_size); | |
12332 | 1237 write_frame_header(s); |
1238 write_subframes(s); | |
1239 write_frame_footer(s); | |
12325 | 1240 return put_bits_count(&s->pb) >> 3; |
1241 } | |
1242 | |
1243 | |
12262
dde20597f15e
Use "const" qualifier for pointers that point to input data of
reimar
parents:
12139
diff
changeset
|
1244 static void update_md5_sum(FlacEncodeContext *s, const int16_t *samples) |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1245 { |
9985 | 1246 #if HAVE_BIGENDIAN |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1247 int i; |
12300 | 1248 for (i = 0; i < s->frame.blocksize * s->channels; i++) { |
12129 | 1249 int16_t smp = av_le2ne16(samples[i]); |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1250 av_md5_update(s->md5ctx, (uint8_t *)&smp, 2); |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1251 } |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1252 #else |
12262
dde20597f15e
Use "const" qualifier for pointers that point to input data of
reimar
parents:
12139
diff
changeset
|
1253 av_md5_update(s->md5ctx, (const uint8_t *)samples, s->frame.blocksize*s->channels*2); |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1254 #endif |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1255 } |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1256 |
12300 | 1257 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1258 static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame, |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1259 int buf_size, void *data) |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1260 { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1261 FlacEncodeContext *s; |
12262
dde20597f15e
Use "const" qualifier for pointers that point to input data of
reimar
parents:
12139
diff
changeset
|
1262 const int16_t *samples = data; |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
1263 int frame_bytes, out_bytes; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1264 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1265 s = avctx->priv_data; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1266 |
7860 | 1267 /* when the last block is reached, update the header in extradata */ |
1268 if (!data) { | |
7864
4820bd751284
write actual min and max frame size to FLAC header. update regression test checksum.
jbr
parents:
7861
diff
changeset
|
1269 s->max_framesize = s->max_encoded_framesize; |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1270 av_md5_final(s->md5ctx, s->md5sum); |
7860 | 1271 write_streaminfo(s, avctx->extradata); |
1272 return 0; | |
1273 } | |
1274 | |
12330 | 1275 /* change max_framesize for small final frame */ |
1276 if (avctx->frame_size < s->frame.blocksize) { | |
1277 s->max_framesize = ff_flac_get_max_frame_size(avctx->frame_size, | |
1278 s->channels, 16); | |
1279 } | |
1280 | |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1281 init_frame(s); |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1282 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1283 copy_samples(s, samples); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1284 |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1285 channel_decorrelation(s); |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1286 |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
1287 frame_bytes = encode_frame(s); |
12331
784ddf9d158a
Simplify verbatim mode fallback by checking the frame size before writing.
jbr
parents:
12330
diff
changeset
|
1288 |
784ddf9d158a
Simplify verbatim mode fallback by checking the frame size before writing.
jbr
parents:
12330
diff
changeset
|
1289 /* fallback to verbatim mode if the compressed frame is larger than it |
784ddf9d158a
Simplify verbatim mode fallback by checking the frame size before writing.
jbr
parents:
12330
diff
changeset
|
1290 would be if encoded uncompressed. */ |
784ddf9d158a
Simplify verbatim mode fallback by checking the frame size before writing.
jbr
parents:
12330
diff
changeset
|
1291 if (frame_bytes > s->max_framesize) { |
784ddf9d158a
Simplify verbatim mode fallback by checking the frame size before writing.
jbr
parents:
12330
diff
changeset
|
1292 s->frame.verbatim_only = 1; |
784ddf9d158a
Simplify verbatim mode fallback by checking the frame size before writing.
jbr
parents:
12330
diff
changeset
|
1293 frame_bytes = encode_frame(s); |
784ddf9d158a
Simplify verbatim mode fallback by checking the frame size before writing.
jbr
parents:
12330
diff
changeset
|
1294 } |
784ddf9d158a
Simplify verbatim mode fallback by checking the frame size before writing.
jbr
parents:
12330
diff
changeset
|
1295 |
12329
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
1296 if (buf_size < frame_bytes) { |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
1297 av_log(avctx, AV_LOG_ERROR, "output buffer too small\n"); |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
1298 return 0; |
6644e439130d
Calculate an exact frame size before writing. Now the buffer size requirements
jbr
parents:
12328
diff
changeset
|
1299 } |
12325 | 1300 out_bytes = write_frame(s, frame, buf_size); |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1301 |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1302 s->frame_count++; |
12304 | 1303 avctx->coded_frame->pts = s->sample_count; |
7860 | 1304 s->sample_count += avctx->frame_size; |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1305 update_md5_sum(s, samples); |
7864
4820bd751284
write actual min and max frame size to FLAC header. update regression test checksum.
jbr
parents:
7861
diff
changeset
|
1306 if (out_bytes > s->max_encoded_framesize) |
4820bd751284
write actual min and max frame size to FLAC header. update regression test checksum.
jbr
parents:
7861
diff
changeset
|
1307 s->max_encoded_framesize = out_bytes; |
9212
c7a8e302b98a
flacenc: remove unneeded variable, 'min_encoded_framesize' and use
jbr
parents:
9209
diff
changeset
|
1308 if (out_bytes < s->min_framesize) |
c7a8e302b98a
flacenc: remove unneeded variable, 'min_encoded_framesize' and use
jbr
parents:
9209
diff
changeset
|
1309 s->min_framesize = out_bytes; |
7860 | 1310 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1311 return out_bytes; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1312 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1313 |
12300 | 1314 |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6341
diff
changeset
|
1315 static av_cold int flac_encode_close(AVCodecContext *avctx) |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1316 { |
7861
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1317 if (avctx->priv_data) { |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1318 FlacEncodeContext *s = avctx->priv_data; |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1319 av_freep(&s->md5ctx); |
f092dd630095
write MD5 checksum to FLAC header. update regression tests.
jbr
parents:
7860
diff
changeset
|
1320 } |
3358
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1321 av_freep(&avctx->extradata); |
4ae69b5b596b
stereo decorrelation support by (Justin Ruggles jruggle earthlink net>)
michael
parents:
3357
diff
changeset
|
1322 avctx->extradata_size = 0; |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1323 av_freep(&avctx->coded_frame); |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1324 return 0; |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1325 } |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1326 |
12300 | 1327 |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1328 AVCodec flac_encoder = { |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1329 "flac", |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
10424
diff
changeset
|
1330 AVMEDIA_TYPE_AUDIO, |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1331 CODEC_ID_FLAC, |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1332 sizeof(FlacEncodeContext), |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1333 flac_encode_init, |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1334 flac_encode_frame, |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1335 flac_encode_close, |
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1336 NULL, |
7860 | 1337 .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY, |
10145
7955db355703
Make sample_fmts and channel_layouts compound literals const to reduce size of
reimar
parents:
9985
diff
changeset
|
1338 .sample_fmts = (const enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE}, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6763
diff
changeset
|
1339 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), |
3353
5b901881d6ed
first rudimentary version of (Justin Ruggles jruggle earthlink net) flac encoder
michael
parents:
diff
changeset
|
1340 }; |