1 /*
2 * FLAC audio encoder
3 * Copyright (c) 2006 Justin Ruggles <justin.ruggles@gmail.com>
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
36
37 #define FLAC_SUBFRAME_CONSTANT 0
38 #define FLAC_SUBFRAME_VERBATIM 1
39 #define FLAC_SUBFRAME_FIXED 8
40 #define FLAC_SUBFRAME_LPC 32
41
42 #define MAX_FIXED_ORDER 4
43 #define MAX_PARTITION_ORDER 8
44 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
45 #define MAX_LPC_PRECISION 15
46 #define MAX_LPC_SHIFT 15
47
51 };
52
66
72
85
94
119
120
121 /**
122 * Write streaminfo metadata block to byte array.
123 */
125 {
127
130
131 /* streaminfo metadata block */
139 /* write 36-bit sample count in 2 put_bits() calls */
143 memcpy(&header[18], s->
md5sum, 16);
144 }
145
146
147 /**
148 * Set blocksize based on samplerate.
149 * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds.
150 */
152 {
153 int i;
154 int target;
155 int blocksize;
156
159 target = (samplerate * block_time_ms) / 1000;
160 for (i = 0; i < 16; i++) {
164 }
165 }
166 return blocksize;
167 }
168
169
171 {
174
176
180 break;
183 break;
185 av_log(avctx,
AV_LOG_DEBUG,
" lpc type: Levinson-Durbin recursion with Welch window\n");
186 break;
190 break;
191 }
192
195
199 break;
202 break;
205 break;
208 break;
211 break;
214 break;
215 }
216
217
220
222
225 }
226
227
229 {
235
237
242 break;
248 break;
249 }
250
253 channels, FLAC_MAX_CHANNELS);
255 }
257
258 /* find samplerate in table */
259 if (freq < 1)
260 return -1;
261 for (i = 4; i < 12; i++) {
266 break;
267 }
268 }
269 /* if not in table, samplerate is non-standard */
270 if (i == 12) {
271 if (freq % 1000 == 0 && freq < 255000) {
274 } else if (freq % 10 == 0 && freq < 655350) {
277 } else if (freq < 65535) {
280 } else {
283 }
285 }
286
287 /* set compression option defaults based on avctx->compression_level */
290 else
292
294 if (level > 12) {
298 }
299
300 s->
options.
block_time_ms = ((
int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
301
307 FF_LPC_TYPE_LEVINSON})[level];
308
309 s->
options.
min_prediction_order = ((
int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];
310 s->
options.
max_prediction_order = ((
int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level];
311
317 ORDER_METHOD_SEARCH})[level];
318
323 }
325 s->
options.
min_partition_order = ((
int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];
327 s->
options.
max_partition_order = ((
int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
328
337 }
343 }
345 }
354 }
360 }
362 }
367 }
368
375 }
376 } else {
378 }
380
381 /* set maximum encoded frame size in verbatim mode */
385
386 /* initialize MD5 context */
391
393 if (!streaminfo)
398
401
402 if (channels == 3 &&
404 channels == 4 &&
407 channels == 5 &&
410 channels == 6 &&
415 "output stream will have incorrect "
416 "channel layout.\n");
417 } else {
419 "will use Flac channel layout for "
420 "%d channels.\n", channels);
421 }
422 }
423
426
430
432
434 }
435
436
438 {
439 int i, ch;
441
443
444 for (i = 0; i < 16; i++) {
449 break;
450 }
451 }
452 if (i == 16) {
457 } else {
460 }
461 }
462
463 for (ch = 0; ch < s->
channels; ch++) {
465
468
471 else
473 }
474
476 }
477
478
479 /**
480 * Copy channel-interleaved input samples into separate subframes.
481 */
483 {
484 int i, j, ch;
488
489 #define COPY_SAMPLES(bits) do { \
490 const int ## bits ## _t *samples0 = samples; \
491 frame = &s->frame; \
492 for (i = 0, j = 0; i < frame->blocksize; i++) \
493 for (ch = 0; ch < s->channels; ch++, j++) \
494 frame->subframes[ch].samples[i] = samples0[j] >> shift; \
495 } while (0)
496
499 else
501 }
502
503
505 {
506 int i;
508
509 for (i = 0; i <
n; i++) {
511 v ^= v >> 31;
512 count += (v >> k) + 1 + k;
513 }
515 }
516
517
519 int pred_order)
520 {
521 int p, porder, psize;
522 int i, part_end;
524
525 /* subframe header */
526 count += 8;
527
528 /* subframe */
533 } else {
534 /* warm-up samples */
535 count += pred_order * sub->
obits;
536
537 /* LPC coefficients */
540
541 /* rice-encoded block */
542 count += 2;
543
544 /* partition order */
547 count += 4;
548
549 /* residual */
550 i = pred_order;
551 part_end = psize;
552 for (p = 0; p < 1 << porder; p++) {
556 i = part_end;
558 }
559 }
560
562 }
563
564
565 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
566
567 /**
568 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
569 */
571 {
572 int k;
573 uint64_t sum2;
574
575 if (sum <= n >> 1)
576 return 0;
577 sum2 = sum - (n >> 1);
578 k =
av_log2(av_clipl_int32(sum2 / n));
579 return FFMIN(k, max_param);
580 }
581
582
584 uint64_t *sums,
int n,
int pred_order)
585 {
586 int i;
587 int k, cnt, part, max_param;
588 uint64_t all_bits;
589
591
592 part = (1 << porder);
593 all_bits = 4 * part;
594
595 cnt = (n >> porder) - pred_order;
596 for (i = 0; i < part; i++) {
600 cnt = n >> porder;
601 }
602
604
605 return all_bits;
606 }
607
608
611 {
612 int i, j;
613 int parts;
614 uint32_t *
res, *res_end;
615
616 /* sums for highest level */
617 parts = (1 << pmax);
618 res = &data[pred_order];
619 res_end = &data[n >> pmax];
620 for (i = 0; i < parts; i++) {
621 uint64_t sum = 0;
622 while (res < res_end)
623 sum += *(res++);
624 sums[pmax][i] = sum;
625 res_end += n >> pmax;
626 }
627 /* sums for lower levels */
628 for (i = pmax - 1; i >= pmin; i--) {
629 parts = (1 << i);
630 for (j = 0; j < parts; j++)
631 sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
632 }
633 }
634
635
638 {
639 int i;
641 int opt_porder;
643 uint32_t *udata;
645
649
651
653 for (i = 0; i <
n; i++)
654 udata[i] = (2*data[i]) ^ (data[i]>>31);
655
656 calc_sums(pmin, pmax, udata, n, pred_order, sums);
657
658 opt_porder = pmin;
659 bits[pmin] = UINT32_MAX;
660 for (i = pmin; i <= pmax; i++) {
662 if (bits[i] <= bits[opt_porder]) {
663 opt_porder = i;
664 *rc = tmp_rc;
665 }
666 }
667
669 return bits[opt_porder];
670 }
671
672
674 {
676 if (order > 0)
678 return porder;
679 }
680
681
684 {
689
696 }
697
698
700 int order)
701 {
702 int i;
703
704 for (i = 0; i < order; i++)
705 res[i] = smp[i];
706
707 if (order == 0) {
708 for (i = order; i <
n; i++)
709 res[i] = smp[i];
710 } else if (order == 1) {
711 for (i = order; i <
n; i++)
712 res[i] = smp[i] - smp[i-1];
713 } else if (order == 2) {
714 int a = smp[order-1] - smp[order-2];
715 for (i = order; i <
n; i += 2) {
716 int b = smp[i ] - smp[i-1];
718 a = smp[i+1] - smp[i ];
720 }
721 } else if (order == 3) {
722 int a = smp[order-1] - smp[order-2];
723 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
724 for (i = order; i <
n; i += 2) {
725 int b = smp[i ] - smp[i-1];
728 a = smp[i+1] - smp[i ];
730 res[i+1] = c - d;
731 }
732 } else {
733 int a = smp[order-1] - smp[order-2];
734 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
735 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
736 for (i = order; i <
n; i += 2) {
737 int b = smp[i ] - smp[i-1];
740 res[i ] = f - e;
741 a = smp[i+1] - smp[i ];
743 e = c - d;
744 res[i+1] = e - f;
745 }
746 }
747 }
748
749
751 {
753 int min_order, max_order, opt_order, omethod;
759
765
766 /* CONSTANT */
767 for (i = 1; i <
n; i++)
768 if(smp[i] != smp[0])
769 break;
770 if (i == n) {
772 res[0] = smp[0];
774 }
775
776 /* VERBATIM */
779 memcpy(res, smp, n *
sizeof(
int32_t));
781 }
782
786
787 /* FIXED */
794 opt_order = 0;
795 bits[0] = UINT32_MAX;
796 for (i = min_order; i <= max_order; i++) {
799 if (bits[i] < bits[opt_order])
800 opt_order = i;
801 }
802 sub->
order = opt_order;
804 if (sub->
order != max_order) {
807 }
809 }
810
811 /* LPC */
817
821 int levels = 1 << omethod;
823 int order = -1;
824 int opt_index = levels-1;
825 opt_order = max_order-1;
826 bits[opt_index] = UINT32_MAX;
827 for (i = levels-1; i >= 0; i--) {
828 int last_order = order;
829 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
830 order = av_clip(order, min_order - 1, max_order - 1);
831 if (order == last_order)
832 continue;
834 shift[order]);
836 if (bits[i] < bits[opt_index]) {
837 opt_index = i;
838 opt_order = order;
839 }
840 }
841 opt_order++;
843 // brute-force optimal order search
845 opt_order = 0;
846 bits[0] = UINT32_MAX;
847 for (i = min_order-1; i < max_order; i++) {
850 if (bits[i] < bits[opt_order])
851 opt_order = i;
852 }
853 opt_order++;
856 int step;
857
858 opt_order = min_order - 1 + (max_order-min_order)/3;
859 memset(bits, -1, sizeof(bits));
860
861 for (step = 16; step; step >>= 1) {
862 int last = opt_order;
863 for (i = last-step; i <= last+step; i += step) {
864 if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX)
865 continue;
868 if (bits[i] < bits[opt_order])
869 opt_order = i;
870 }
871 }
872 opt_order++;
873 }
874
875 sub->
order = opt_order;
878 for (i = 0; i < sub->
order; i++)
880
882
884
886 }
887
888
890 {
893
894 /*
895 <14> Sync code
896 <1> Reserved
897 <1> Blocking strategy
898 <4> Block size in inter-channel samples
899 <4> Sample rate
900 <4> Channel assignment
901 <3> Sample size in bits
902 <1> Reserved
903 */
904 count = 32;
905
906 /* coded frame number */
908
909 /* explicit block size */
911 count += 8;
913 count += 16;
914
915 /* explicit sample rate */
917
918 /* frame header CRC-8 */
919 count += 8;
920
922 }
923
924
926 {
927 int ch;
929
931
932 for (ch = 0; ch < s->
channels; ch++)
934
935 count += (8 - (count & 7)) & 7; // byte alignment
936 count += 16; // CRC-16
937
938 count >>= 3;
939 if (count > INT_MAX)
942 }
943
944
946 {
947 int ch, i;
948
949 for (ch = 0; ch < s->
channels; ch++) {
952
955 if (v & 1)
956 break;
957 }
958
959 if (v && !(v & 1)) {
961
964
967
968 /* for 24-bit, check if removing wasted bits makes the range better
969 suited for using RICE instead of RICE2 for entropy coding */
972 }
973 }
974 }
975
976
978 int max_rice_param)
979 {
980 int i, best;
982 uint64_t sum[4];
983 uint64_t score[4];
984 int k;
985
986 /* calculate sum of 2nd order residual for each channel */
987 sum[0] = sum[1] = sum[2] = sum[3] = 0;
988 for (i = 2; i <
n; i++) {
989 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
990 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
991 sum[2] +=
FFABS((lt + rt) >> 1);
992 sum[3] +=
FFABS(lt - rt);
995 }
996 /* estimate bit counts */
997 for (i = 0; i < 4; i++) {
1000 }
1001
1002 /* calculate score for each mode */
1003 score[0] = sum[0] + sum[1];
1004 score[1] = sum[0] + sum[3];
1005 score[2] = sum[1] + sum[3];
1006 score[3] = sum[2] + sum[3];
1007
1008 /* return mode with lowest score */
1009 best = 0;
1010 for (i = 1; i < 4; i++)
1011 if (score[i] < score[best])
1012 best = i;
1013
1014 return best;
1015 }
1016
1017
1018 /**
1019 * Perform stereo channel decorrelation.
1020 */
1022 {
1026
1031
1034 return;
1035 }
1036
1040 } else
1042
1043 /* perform decorrelation and adjust bits-per-sample */
1045 return;
1048 for (i = 0; i <
n; i++) {
1049 tmp = left[i];
1050 left[i] = (tmp + right[i]) >> 1;
1051 right[i] = tmp - right[i];
1052 }
1055 for (i = 0; i <
n; i++)
1056 right[i] = left[i] - right[i];
1058 } else {
1059 for (i = 0; i <
n; i++)
1060 left[i] -= right[i];
1062 }
1063 }
1064
1065
1067 {
1070 }
1071
1072
1074 {
1076 int crc;
1077
1079
1083
1086 else
1088
1092
1095 else if (frame->
bs_code[0] == 7)
1097
1102
1107 }
1108
1109
1111 {
1112 int ch;
1113
1114 for (ch = 0; ch < s->
channels; ch++) {
1116 int i, p, porder, psize;
1120
1121 /* subframe header */
1127
1128 /* subframe */
1132 while (res < frame_end)
1134 } else {
1135 /* warm-up samples */
1136 for (i = 0; i < sub->
order; i++)
1138
1139 /* LPC coefficients */
1144 for (i = 0; i < sub->
order; i++)
1146 }
1147
1148 /* rice-encoded block */
1150
1151 /* partition order */
1155
1156 /* residual */
1158 for (p = 0; p < 1 << porder; p++) {
1161 while (res < part_end)
1163 part_end =
FFMIN(frame_end, part_end + psize);
1164 }
1165 }
1166 }
1167 }
1168
1169
1171 {
1172 int crc;
1178 }
1179
1180
1182 {
1188 }
1189
1190
1192 {
1196
1201 }
1202
1204 buf = (
const uint8_t *)samples;
1205 #if HAVE_BIGENDIAN
1207 (const uint16_t *)samples, buf_size / 2);
1209 #endif
1210 } else {
1211 int i;
1212 const int32_t *samples0 = samples;
1214
1217 *tmp++ = (
v ) & 0xFF;
1218 *tmp++ = (v >> 8) & 0xFF;
1219 *tmp++ = (v >> 16) & 0xFF;
1220 }
1222 }
1224
1225 return 0;
1226 }
1227
1228
1231 {
1233 int frame_bytes, out_bytes,
ret;
1234
1236
1237 /* when the last block is reached, update the header in extradata */
1238 if (!frame) {
1242 return 0;
1243 }
1244
1245 /* change max_framesize for small final frame */
1250 }
1251
1253
1255
1257
1259
1261
1262 /* Fall back on verbatim mode if the compressed frame is larger than it
1263 would be if encoded uncompressed. */
1267 if (frame_bytes < 0) {
1269 return frame_bytes;
1270 }
1271 }
1272
1275
1277
1283 }
1286 if (out_bytes < s->min_framesize)
1288
1291 avpkt->
size = out_bytes;
1292 *got_packet_ptr = 1;
1293 return 0;
1294 }
1295
1296
1298 {
1304 }
1307 return 0;
1308 }
1309
1310 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1313 {
"lpc_type",
"LPC algorithm", offsetof(
FlacEncodeContext, options.lpc_type),
AV_OPT_TYPE_INT, {.i64 =
FF_LPC_TYPE_DEFAULT },
FF_LPC_TYPE_DEFAULT,
FF_LPC_TYPE_NB-1,
FLAGS,
"lpc_type" },
1318 {
"lpc_passes",
"Number of passes to use for Cholesky factorization during LPC analysis", offsetof(
FlacEncodeContext, options.lpc_passes),
AV_OPT_TYPE_INT, {.i64 = 2 }, 1, INT_MAX,
FLAGS },
1321 {
"prediction_order_method",
"Search method for selecting prediction order", offsetof(
FlacEncodeContext, options.prediction_order_method),
AV_OPT_TYPE_INT, {.i64 = -1 }, -1,
ORDER_METHOD_LOG,
FLAGS,
"predm" },
1328 {
"ch_mode",
"Stereo decorrelation mode", offsetof(
FlacEncodeContext, options.ch_mode),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1,
FLAC_CHMODE_MID_SIDE,
FLAGS,
"ch_mode" },
1334 { NULL },
1335 };
1336
1338 "FLAC encoder",
1342 };
1343
1358 };