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 int last_order = order;
924 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
925 order = av_clip(order, min_order - 1, max_order - 1);
926 if (order == last_order)
930 if (bits[i] < bits[opt_index]) {
941 for (i = min_order-1; i < max_order; i++) {
944 if (bits[i] < bits[opt_order])
952 opt_order = min_order - 1 + (max_order-min_order)/3;
953 memset(bits, -1,
sizeof(bits));
955 for (step = 16;
step; step >>= 1) {
956 int last = opt_order;
957 for (i = last-step; i <= last+
step; i +=
step) {
958 if (i < min_order-1 || i >= max_order || bits[i] <
UINT32_MAX)
962 if (bits[i] < bits[opt_order])
969 sub->
order = opt_order;
972 for (i = 0; i < sub->
order; i++)
1025 for (ch = 0; ch < s->
channels; ch++)
1028 count += (8 - (count & 7)) & 7;
1044 sum[0] = sum[1] = sum[2] = sum[3] = 0;
1045 for (i = 2; i < n; i++) {
1046 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
1047 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
1048 sum[2] +=
FFABS((lt + rt) >> 1);
1049 sum[3] +=
FFABS(lt - rt);
1050 sum[0] +=
FFABS(lt);
1051 sum[1] +=
FFABS(rt);
1054 for (i = 0; i < 4; i++) {
1060 score[0] = sum[0] + sum[1];
1061 score[1] = sum[0] + sum[3];
1062 score[2] = sum[1] + sum[3];
1063 score[3] = sum[2] + sum[3];
1067 for (i = 1; i < 4; i++)
1068 if (score[i] < score[best])
1072 }
else if (best == 1) {
1074 }
else if (best == 2) {
1088 int32_t *left, *right;
1108 for (i = 0; i < n; i++) {
1110 left[i] = (tmp + right[i]) >> 1;
1111 right[i] = tmp - right[i];
1115 for (i = 0; i < n; i++)
1116 right[i] = left[i] - right[i];
1119 for (i = 0; i < n; i++)
1120 left[i] -= right[i];
1155 else if (frame->
bs_code[0] == 7)
1174 for (ch = 0; ch < s->
channels; ch++) {
1176 int i, p, porder, psize;
1190 while (res < frame_end)
1194 for (i = 0; i < sub->
order; i++)
1202 for (i = 0; i < sub->
order; i++)
1216 for (p = 0; p < 1 << porder; p++) {
1219 while (res < part_end)
1221 part_end =
FFMIN(frame_end, part_end + psize);
1264 int buf_size,
void *
data)
1268 int frame_bytes, out_bytes;
1301 if (buf_size < frame_bytes) {
1313 if (out_bytes < s->min_framesize)
1333 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1336 {
"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" },
1341 {
"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 },
1344 {
"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" },