36 #define FLAC_SUBFRAME_CONSTANT 0
37 #define FLAC_SUBFRAME_VERBATIM 1
38 #define FLAC_SUBFRAME_FIXED 8
39 #define FLAC_SUBFRAME_LPC 32
41 #define MAX_FIXED_ORDER 4
42 #define MAX_PARTITION_ORDER 8
43 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
44 #define MAX_LPC_PRECISION 15
45 #define MAX_LPC_SHIFT 15
142 memcpy(&header[18], s->
md5sum, 16);
156 assert(samplerate > 0);
158 target = (samplerate * block_time_ms) / 1000;
159 for (i = 0; i < 16; i++) {
184 av_log(avctx,
AV_LOG_DEBUG,
" lpc type: Levinson-Durbin recursion with Welch window\n");
257 for (i = 4; i < 12; i++) {
267 if (freq % 1000 == 0 && freq < 255000) {
270 }
else if (freq % 10 == 0 && freq < 655350) {
273 }
else if (freq < 65535) {
295 s->
options.
block_time_ms = ((
int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
302 FF_LPC_TYPE_LEVINSON})[level];
304 s->
options.
min_prediction_order = ((
int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];
305 s->
options.
max_prediction_order = ((
int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level];
312 ORDER_METHOD_SEARCH})[level];
320 s->
options.
min_partition_order = ((
int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];
322 s->
options.
max_partition_order = ((
int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
397 #if FF_API_OLD_ENCODE_AUDIO
423 for (i = 0; i < 16; i++) {
442 for (ch = 0; ch < s->
channels; ch++) {
468 #define COPY_SAMPLES(bits) do { \
469 const int ## bits ## _t *samples0 = samples; \
471 for (i = 0, j = 0; i < frame->blocksize; i++) \
472 for (ch = 0; ch < s->channels; ch++, j++) \
473 frame->subframes[ch].samples[i] = samples0[j] >> shift; \
488 for (i = 0; i < n; i++) {
491 count += (v >> k) + 1 + k;
500 int p, porder, psize;
514 count += pred_order * sub->
obits;
531 for (p = 0; p < 1 << porder; p++) {
544 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
556 sum2 = sum - (n >> 1);
557 k =
av_log2(av_clipl_int32(sum2 / n));
558 return FFMIN(k, max_param);
563 uint64_t *sums,
int n,
int pred_order)
566 int k, cnt, part, max_param;
571 part = (1 << porder);
574 cnt = (n >> porder) - pred_order;
575 for (i = 0; i < part; i++) {
588 static void calc_sums(
int pmin,
int pmax, uint32_t *
data,
int n,
int pred_order,
593 uint32_t *res, *res_end;
597 res = &data[pred_order];
598 res_end = &data[n >> pmax];
599 for (i = 0; i < parts; i++) {
601 while (res < res_end)
604 res_end += n >> pmax;
607 for (i = pmax - 1; i >= pmin; i--) {
609 for (j = 0; j < parts; j++)
610 sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
627 assert(pmin <= pmax);
632 for (i = 0; i < n; i++)
633 udata[i] = (2*data[i]) ^ (data[i]>>31);
635 calc_sums(pmin, pmax, udata, n, pred_order, sums);
638 bits[pmin] = UINT32_MAX;
639 for (i = pmin; i <= pmax; i++) {
641 if (bits[i] <= bits[opt_porder]) {
648 return bits[opt_porder];
683 for (i = 0; i < order; i++)
687 for (i = order; i < n; i++)
689 }
else if (order == 1) {
690 for (i = order; i < n; i++)
691 res[i] = smp[i] - smp[i-1];
692 }
else if (order == 2) {
693 int a = smp[order-1] - smp[order-2];
694 for (i = order; i < n; i += 2) {
695 int b = smp[i ] - smp[i-1];
697 a = smp[i+1] - smp[i ];
700 }
else if (order == 3) {
701 int a = smp[order-1] - smp[order-2];
702 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
703 for (i = order; i < n; i += 2) {
704 int b = smp[i ] - smp[i-1];
707 a = smp[i+1] - smp[i ];
712 int a = smp[order-1] - smp[order-2];
713 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
714 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
715 for (i = order; i < n; i += 2) {
716 int b = smp[i ] - smp[i-1];
720 a = smp[i+1] - smp[i ];
732 int min_order, max_order, opt_order, omethod;
746 for (i = 1; i < n; i++)
758 memcpy(res, smp, n *
sizeof(
int32_t));
774 bits[0] = UINT32_MAX;
775 for (i = min_order; i <= max_order; i++) {
778 if (bits[i] < bits[opt_order])
781 sub->
order = opt_order;
783 if (sub->
order != max_order) {
800 int levels = 1 << omethod;
803 int opt_index = levels-1;
804 opt_order = max_order-1;
805 bits[opt_index] = UINT32_MAX;
806 for (i = levels-1; i >= 0; i--) {
807 int last_order = order;
808 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
809 order = av_clip(order, min_order - 1, max_order - 1);
810 if (order == last_order)
815 if (bits[i] < bits[opt_index]) {
825 bits[0] = UINT32_MAX;
826 for (i = min_order-1; i < max_order; i++) {
829 if (bits[i] < bits[opt_order])
837 opt_order = min_order - 1 + (max_order-min_order)/3;
838 memset(bits, -1,
sizeof(bits));
840 for (step = 16;
step; step >>= 1) {
841 int last = opt_order;
842 for (i = last-step; i <= last+
step; i +=
step) {
843 if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX)
847 if (bits[i] < bits[opt_order])
854 sub->
order = opt_order;
857 for (i = 0; i < sub->
order; i++)
911 for (ch = 0; ch < s->
channels; ch++)
914 count += (8 - (count & 7)) & 7;
928 for (ch = 0; ch < s->
channels; ch++) {
966 sum[0] = sum[1] = sum[2] = sum[3] = 0;
967 for (i = 2; i < n; i++) {
968 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
969 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
970 sum[2] +=
FFABS((lt + rt) >> 1);
971 sum[3] +=
FFABS(lt - rt);
976 for (i = 0; i < 4; i++) {
982 score[0] = sum[0] + sum[1];
983 score[1] = sum[0] + sum[3];
984 score[2] = sum[1] + sum[3];
985 score[3] = sum[2] + sum[3];
989 for (i = 1; i < 4; i++)
990 if (score[i] < score[best])
1027 for (i = 0; i < n; i++) {
1029 left[i] = (tmp + right[i]) >> 1;
1030 right[i] = tmp - right[i];
1034 for (i = 0; i < n; i++)
1035 right[i] = left[i] - right[i];
1038 for (i = 0; i < n; i++)
1039 left[i] -= right[i];
1074 else if (frame->
bs_code[0] == 7)
1093 for (ch = 0; ch < s->
channels; ch++) {
1095 int i, p, porder, psize;
1111 while (res < frame_end)
1115 for (i = 0; i < sub->
order; i++)
1123 for (i = 0; i < sub->
order; i++)
1137 for (p = 0; p < 1 << porder; p++) {
1140 while (res < part_end)
1142 part_end =
FFMIN(frame_end, part_end + psize);
1183 buf = (
const uint8_t *)samples;
1186 (
const uint16_t *)samples, buf_size / 2);
1196 *tmp++ = (v ) & 0xFF;
1197 *tmp++ = (v >> 8) & 0xFF;
1198 *tmp++ = (v >> 16) & 0xFF;
1209 const AVFrame *frame,
int *got_packet_ptr)
1212 int frame_bytes, out_bytes, ret;
1246 if (frame_bytes < 0) {
1267 if (out_bytes < s->min_framesize)
1272 avpkt->
size = out_bytes;
1273 *got_packet_ptr = 1;
1288 #if FF_API_OLD_ENCODE_AUDIO
1294 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1297 {
"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" },
1302 {
"lpc_passes",
"Number of passes to use for Cholesky factorization during LPC analysis", offsetof(
FlacEncodeContext, options.lpc_passes),
AV_OPT_TYPE_INT, {.i64 = 1 }, 1, INT_MAX,
FLAGS },
1305 {
"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" },
1312 {
"ch_mode",
"Stereo decorrelation mode", offsetof(
FlacEncodeContext, options.ch_mode),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1,
FLAC_CHMODE_MID_SIDE,
FLAGS,
"ch_mode" },