32 #define FLAC_SUBFRAME_CONSTANT 0
33 #define FLAC_SUBFRAME_VERBATIM 1
34 #define FLAC_SUBFRAME_FIXED 8
35 #define FLAC_SUBFRAME_LPC 32
37 #define MAX_FIXED_ORDER 4
38 #define MAX_PARTITION_ORDER 8
39 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
40 #define MAX_LPC_PRECISION 15
41 #define MAX_LPC_SHIFT 15
42 #define MAX_RICE_PARAM 14
126 memcpy(&header[18], s->
md5sum, 16);
140 assert(samplerate > 0);
142 target = (samplerate * block_time_ms) / 1000;
143 for (i = 0; i < 16; i++) {
168 av_log(avctx,
AV_LOG_DEBUG,
" lpc type: Levinson-Durbin recursion with Welch window\n");
231 for (i = 4; i < 12; i++) {
241 if (freq % 1000 == 0 && freq < 255000) {
244 }
else if (freq % 10 == 0 && freq < 655350) {
247 }
else if (freq < 65535) {
269 s->
options.
block_time_ms = ((
int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
276 FF_LPC_TYPE_LEVINSON})[level];
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];
286 ORDER_METHOD_SEARCH})[level];
294 s->
options.
min_partition_order = ((
int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];
296 s->
options.
max_partition_order = ((
int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
299 #if FF_API_FLAC_GLOBAL_OPTS
307 if (avctx->lpc_passes < 0) {
310 }
else if (avctx->lpc_passes == 0) {
361 #if FF_API_FLAC_GLOBAL_OPTS
362 if (avctx->prediction_order_method >= 0) {
365 avctx->prediction_order_method);
371 if (avctx->min_partition_order >= 0) {
374 avctx->min_partition_order);
379 if (avctx->max_partition_order >= 0) {
382 avctx->max_partition_order);
406 #if FF_API_FLAC_GLOBAL_OPTS
408 if (avctx->lpc_coeff_precision > 0) {
411 avctx->lpc_coeff_precision);
458 for (i = 0; i < 16; i++) {
477 for (ch = 0; ch < s->
channels; ch++)
493 for (i = 0, j = 0; i < frame->
blocksize; i++)
494 for (ch = 0; ch < s->
channels; ch++, j++)
504 for (i = 0; i < n; i++) {
505 int32_t
v = -2 * res[i] - 1;
507 count += (v >> k) + 1 + k;
516 int p, porder, psize;
530 count += pred_order * sub->
obits;
547 for (p = 0; p < 1 << porder; p++) {
560 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
572 sum2 = sum - (n >> 1);
573 k = av_log2(n < 256 ?
FASTDIV(sum2, n) : sum2 / n);
579 uint32_t *sums,
int n,
int pred_order)
585 part = (1 << porder);
588 cnt = (n >> porder) - pred_order;
589 for (i = 0; i < part; i++) {
602 static void calc_sums(
int pmin,
int pmax, uint32_t *
data,
int n,
int pred_order,
607 uint32_t *res, *res_end;
611 res = &data[pred_order];
612 res_end = &data[n >> pmax];
613 for (i = 0; i < parts; i++) {
615 while (res < res_end)
618 res_end += n >> pmax;
621 for (i = pmax - 1; i >= pmin; i--) {
623 for (j = 0; j < parts; j++)
624 sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
630 int32_t *
data,
int n,
int pred_order)
641 assert(pmin <= pmax);
644 for (i = 0; i < n; i++)
645 udata[i] = (2*data[i]) ^ (data[i]>>31);
647 calc_sums(pmin, pmax, udata, n, pred_order, sums);
651 for (i = pmin; i <= pmax; i++) {
653 if (bits[i] <= bits[opt_porder]) {
660 return bits[opt_porder];
666 int porder =
FFMIN(max_porder, av_log2(n^(n-1)));
668 porder =
FFMIN(porder, av_log2(n/order));
681 uint32_t
bits = 8 + pred_order * sub->
obits + 2 + 4;
695 for (i = 0; i < order; i++)
699 for (i = order; i < n; i++)
701 }
else if (order == 1) {
702 for (i = order; i < n; i++)
703 res[i] = smp[i] - smp[i-1];
704 }
else if (order == 2) {
705 int a = smp[order-1] - smp[order-2];
706 for (i = order; i < n; i += 2) {
707 int b = smp[i ] - smp[i-1];
709 a = smp[i+1] - smp[i ];
712 }
else if (order == 3) {
713 int a = smp[order-1] - smp[order-2];
714 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
715 for (i = order; i < n; i += 2) {
716 int b = smp[i ] - smp[i-1];
719 a = smp[i+1] - smp[i ];
724 int a = smp[order-1] - smp[order-2];
725 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
726 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
727 for (i = order; i < n; i += 2) {
728 int b = smp[i ] - smp[i-1];
732 a = smp[i+1] - smp[i ];
742 int c = coefs[(x)-1];\
749 const int32_t *smp,
int n,
int order,
750 const int32_t *coefs,
int shift,
int big)
753 for (i = order; i < n; i += 2) {
754 int s = smp[i-order];
803 res[i ] = smp[i ] - (p0 >> shift);
804 res[i+1] = smp[i+1] - (p1 >> shift);
810 int order,
const int32_t *coefs,
int shift)
813 for (i = 0; i < order; i++)
816 for (i = order; i < n; i += 2) {
820 for (j = 0; j < order; j++) {
826 res[i ] = smp[i ] - (p0 >> shift);
827 res[i+1] = smp[i+1] - (p1 >> shift);
848 int min_order, max_order, opt_order, omethod;
862 for (i = 1; i < n; i++)
874 memcpy(res, smp, n *
sizeof(int32_t));
891 for (i = min_order; i <= max_order; i++) {
894 if (bits[i] < bits[opt_order])
897 sub->
order = opt_order;
899 if (sub->
order != max_order) {
916 int levels = 1 << omethod;
919 int opt_index = levels-1;
920 opt_order = max_order-1;
922 for (i = levels-1; i >= 0; i--) {
923 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
928 if (bits[i] < bits[opt_index]) {
939 for (i = min_order-1; i < max_order; i++) {
942 if (bits[i] < bits[opt_order])
950 opt_order = min_order - 1 + (max_order-min_order)/3;
951 memset(bits, -1,
sizeof(bits));
953 for (step = 16;
step; step >>= 1) {
954 int last = opt_order;
955 for (i = last-step; i <= last+
step; i +=
step) {
956 if (i < min_order-1 || i >= max_order || bits[i] <
UINT32_MAX)
960 if (bits[i] < bits[opt_order])
967 sub->
order = opt_order;
970 for (i = 0; i < sub->
order; i++)
1023 for (ch = 0; ch < s->
channels; ch++)
1026 count += (8 - (count & 7)) & 7;
1042 sum[0] = sum[1] = sum[2] = sum[3] = 0;
1043 for (i = 2; i < n; i++) {
1044 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
1045 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
1046 sum[2] +=
FFABS((lt + rt) >> 1);
1047 sum[3] +=
FFABS(lt - rt);
1048 sum[0] +=
FFABS(lt);
1049 sum[1] +=
FFABS(rt);
1052 for (i = 0; i < 4; i++) {
1058 score[0] = sum[0] + sum[1];
1059 score[1] = sum[0] + sum[3];
1060 score[2] = sum[1] + sum[3];
1061 score[3] = sum[2] + sum[3];
1065 for (i = 1; i < 4; i++)
1066 if (score[i] < score[best])
1070 }
else if (best == 1) {
1072 }
else if (best == 2) {
1086 int32_t *left, *right;
1106 for (i = 0; i < n; i++) {
1108 left[i] = (tmp + right[i]) >> 1;
1109 right[i] = tmp - right[i];
1113 for (i = 0; i < n; i++)
1114 right[i] = left[i] - right[i];
1117 for (i = 0; i < n; i++)
1118 left[i] -= right[i];
1153 else if (frame->
bs_code[0] == 7)
1172 for (ch = 0; ch < s->
channels; ch++) {
1174 int i, p, porder, psize;
1188 while (res < frame_end)
1192 for (i = 0; i < sub->
order; i++)
1200 for (i = 0; i < sub->
order; i++)
1214 for (p = 0; p < 1 << porder; p++) {
1217 while (res < part_end)
1219 part_end =
FFMIN(frame_end, part_end + psize);
1262 int buf_size,
void *
data)
1266 int frame_bytes, out_bytes;
1299 if (buf_size < frame_bytes) {
1311 if (out_bytes < s->min_framesize)
1331 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1334 {
"lpc_type",
"LPC algorithm", offsetof(
FlacEncodeContext, options.lpc_type),
AV_OPT_TYPE_INT, {.dbl =
FF_LPC_TYPE_DEFAULT },
FF_LPC_TYPE_DEFAULT,
FF_LPC_TYPE_NB-1,
FLAGS,
"lpc_type" },
1339 {
"lpc_passes",
"Number of passes to use for Cholesky factorization during LPC analysis", offsetof(
FlacEncodeContext, options.lpc_passes),
AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX,
FLAGS },
1342 {
"prediction_order_method",
"Search method for selecting prediction order", offsetof(
FlacEncodeContext, options.prediction_order_method),
AV_OPT_TYPE_INT, {.dbl = -1 }, -1,
ORDER_METHOD_LOG,
FLAGS,
"predm" },