130 #define OFFSET(x) offsetof(ShowCWTContext, x)
131 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
205 for (
int n = 0; n <
s->nb_threads; n++)
211 for (
int n = 0; n <
s->nb_threads; n++)
217 for (
int n = 0; n <
s->frequency_band_count; n++)
246 int frequency_band_count,
247 float frequency_range,
248 float frequency_offset,
249 int frequency_scale,
float deviation)
254 for (
int y = 0; y < frequency_band_count; y++) {
255 float frequency = frequency_range * (1.f - (
float)y / frequency_band_count) + frequency_offset;
256 float frequency_derivative = frequency_range / frequency_band_count;
258 switch (frequency_scale) {
260 frequency =
powf(2.
f, frequency);
261 frequency_derivative *= logf(2.
f) * frequency;
264 frequency = 600.f * sinhf(frequency / 6.
f);
265 frequency_derivative *=
sqrtf(frequency * frequency + 360000.
f) / 6.f;
268 frequency = 700.f * (
powf(10.
f, frequency / 2595.
f) - 1.f);
269 frequency_derivative *= (frequency + 700.f) * logf(10.
f) / 2595.f;
272 frequency = 676170.4f / (47.06538f -
expf(frequency * 0.08950404
f)) - 14678.49
f;
273 frequency_derivative *= (frequency * frequency + 14990.4f * frequency + 4577850.f) / 160514.
f;
276 frequency = frequency * frequency;
277 frequency_derivative *= 2.f *
sqrtf(frequency);
280 frequency = frequency * frequency * frequency;
281 frequency_derivative *= 3.f *
powf(frequency, 2.
f / 3.
f);
284 frequency = frequency * frequency * frequency * frequency;
285 frequency_derivative *= 4.f *
powf(frequency, 3.
f / 4.
f);
288 frequency = 2.f *
powf(frequency, 3.
f / 2.
f) / 3.f;
289 frequency_derivative *=
sqrtf(frequency);
296 ret = 1.f / (frequency_derivative * deviation);
304 const float max =
s->maximum_intensity;
305 const float min =
s->minimum_intensity;
338 const int hop_size =
s->hop_size;
340 float *cache = (
float *)
s->cache->extended_data[ch];
343 const int offset = (
s->input_padding_size - hop_size) >> 1;
353 if (fin &&
s->hop_index + fin->
nb_samples < hop_size)
356 memset(
src, 0,
sizeof(
float) *
s->fft_size);
357 for (
int n = 0; n < hop_size; n++)
365 #define DRAW_BAR_COLOR(x) \
372 float mul = (Y - ht) * bh[0]; \
373 dstY[x] = av_clip_uint8(lrintf(Y * mul * 255.f)); \
374 dstU[x] = av_clip_uint8(lrintf((U-0.5f) * 128.f + 128)); \
375 dstV[x] = av_clip_uint8(lrintf((V-0.5f) * 128.f + 128)); \
380 float Y,
float U,
float V)
382 float *bh = ((
float *)
s->bh_out->extended_data[0]) + y;
383 const ptrdiff_t ylinesize =
s->outpicref->linesize[0];
384 const ptrdiff_t ulinesize =
s->outpicref->linesize[1];
385 const ptrdiff_t vlinesize =
s->outpicref->linesize[2];
386 const int direction =
s->direction;
387 const int sono_size =
s->sono_size;
388 const int bar_size =
s->bar_size;
389 const float rcp_bar_h = 1.f / bar_size;
390 uint8_t *dstY, *dstU, *dstV;
393 bh[0] = 1.f / (
Y + 0.0001f);
396 dstY =
s->outpicref->data[0] + y * ylinesize;
397 dstU =
s->outpicref->data[1] + y * ulinesize;
398 dstV =
s->outpicref->data[2] + y * vlinesize;
399 for (
int x = 0; x < bar_size; x++) {
400 float ht = (bar_size - x) * rcp_bar_h;
405 dstY =
s->outpicref->data[0] + y * ylinesize;
406 dstU =
s->outpicref->data[1] + y * ulinesize;
407 dstV =
s->outpicref->data[2] + y * vlinesize;
408 for (
int x = 0; x < bar_size; x++) {
409 float ht = x * rcp_bar_h;
414 dstY =
s->outpicref->data[0] +
w - 1 - y;
415 dstU =
s->outpicref->data[1] +
w - 1 - y;
416 dstV =
s->outpicref->data[2] +
w - 1 - y;
417 for (
int x = 0; x < bar_size; x++) {
418 float ht = (bar_size - x) * rcp_bar_h;
426 dstY =
s->outpicref->data[0] +
w - 1 - y + ylinesize * sono_size;
427 dstU =
s->outpicref->data[1] +
w - 1 - y + ulinesize * sono_size;
428 dstV =
s->outpicref->data[2] +
w - 1 - y + vlinesize * sono_size;
429 for (
int x = 0; x < bar_size; x++) {
430 float ht = x * rcp_bar_h;
443 const ptrdiff_t ylinesize =
s->outpicref->linesize[0];
444 const ptrdiff_t ulinesize =
s->outpicref->linesize[1];
445 const ptrdiff_t vlinesize =
s->outpicref->linesize[2];
446 const ptrdiff_t alinesize =
s->outpicref->linesize[3];
447 const float log_factor = 1.f/logf(
s->logarithmic_basis);
448 const int count =
s->frequency_band_count;
449 const int start = (count * jobnr) / nb_jobs;
450 const int end = (count * (jobnr+1)) / nb_jobs;
451 const int nb_channels =
s->nb_channels;
452 const int iscale =
s->intensity_scale;
453 const int ihop_index =
s->ihop_index;
454 const int ihop_size =
s->ihop_size;
455 const float rotation =
s->rotation;
456 const int direction =
s->direction;
457 uint8_t *dstY, *dstU, *dstV, *dstA;
458 const int sono_size =
s->sono_size;
459 const int bar_size =
s->bar_size;
460 const int mode =
s->mode;
461 const int w_1 =
s->w - 1;
462 const int x =
s->pos;
465 for (
int y = start; y < end; y++) {
467 0 * ihop_size + ihop_index;
475 dstY =
s->outpicref->data[0] + y * ylinesize;
476 dstU =
s->outpicref->data[1] + y * ulinesize;
477 dstV =
s->outpicref->data[2] + y * vlinesize;
478 dstA =
s->outpicref->data[3] ?
s->outpicref->data[3] + y * alinesize :
NULL;
482 dstY =
s->outpicref->data[0] + x * ylinesize + w_1 - y;
483 dstU =
s->outpicref->data[1] + x * ulinesize + w_1 - y;
484 dstV =
s->outpicref->data[2] + x * vlinesize + w_1 - y;
485 dstA =
s->outpicref->data[3] ?
s->outpicref->data[3] + x * alinesize + w_1 - y :
NULL;
495 switch (
s->direction) {
497 memmove(dstY, dstY + 1, w_1);
498 memmove(dstU, dstU + 1, w_1);
499 memmove(dstV, dstV + 1, w_1);
501 memmove(dstA, dstA + 1, w_1);
504 memmove(dstY + 1, dstY, w_1);
505 memmove(dstU + 1, dstU, w_1);
506 memmove(dstV + 1, dstV, w_1);
508 memmove(dstA + 1, dstA, w_1);
531 u = hypotf(
src[0].re,
src[0].im);
545 U = 0.5f + 0.5f * z *
u;
546 V = 0.5f + 0.5f * z * v;
562 const int nb_channels =
s->nb_channels;
563 const float yf = 1.f / nb_channels;
567 for (
int ch = 0; ch < nb_channels; ch++) {
571 z = hypotf(srcn[0].re, srcn[0].im);
575 U += z * yf *
sinf(2.
f *
M_PI * (ch * yf + rotation));
576 V += z * yf *
cosf(2.
f *
M_PI * (ch * yf + rotation));
592 Y = hypotf(
src[0].re,
src[0].im);
595 U = 0.5f + 0.5f *
U *
Y /
M_PI;
611 Y = 0.5f + 0.5f *
Y /
M_PI;
623 Y = hypotf(
src[0].re,
src[0].im);
644 const int ch = *(
int *)
arg;
648 const int output_padding_size =
s->output_padding_size;
649 const int input_padding_size =
s->input_padding_size;
650 const float scale = 1.f / input_padding_size;
651 const int ihop_size =
s->ihop_size;
652 const int count =
s->frequency_band_count;
653 const int start = (count * jobnr) / nb_jobs;
654 const int end = (count * (jobnr+1)) / nb_jobs;
656 for (
int y = start; y < end; y++) {
662 const unsigned *
index = (
const unsigned *)
s->index;
663 const int kernel_start =
s->kernel_start[y];
664 const int kernel_stop =
s->kernel_stop[y];
665 const int kernel_range = kernel_stop - kernel_start + 1;
668 if (kernel_start >= 0) {
670 memcpy(srcx, fft_out + kernel_start,
sizeof(*fft_out) * kernel_range);
673 memcpy(srcx+
offset, fft_out,
sizeof(*fft_out) * (kernel_range-
offset));
674 memcpy(srcx, fft_out+input_padding_size-
offset,
sizeof(*fft_out)*
offset);
677 s->fdsp->vector_fmul_scalar((
float *)srcx, (
const float *)srcx,
scale,
FFALIGN(kernel_range * 2, 4));
678 s->fdsp->vector_fmul((
float *)dstx, (
const float *)srcx,
679 (
const float *)kernel,
FFALIGN(kernel_range * 2, 16));
681 memset(isrc, 0,
sizeof(*isrc) * output_padding_size);
683 const unsigned *kindex =
index + kernel_start;
684 for (
int i = 0;
i < kernel_range;
i++) {
685 const unsigned n = kindex[
i];
687 isrc[n].re += dstx[
i].re;
688 isrc[n].im += dstx[
i].im;
691 for (
int i = 0;
i < kernel_range;
i++) {
692 const unsigned n = (
i-kernel_start) & (output_padding_size-1);
694 isrc[n].re += dstx[
i].re;
695 isrc[n].im += dstx[
i].im;
699 s->itx_fn(
s->ifft[jobnr], idst, isrc,
sizeof(*isrc));
701 memcpy(chout, idst,
sizeof(*chout) * ihop_size);
702 for (
int n = 0; n < ihop_size; n++) {
703 chout[n].
re += over[n].
re;
704 chout[n].
im += over[n].
im;
706 memcpy(over, idst + ihop_size,
sizeof(*over) * ihop_size);
715 const int size =
s->input_padding_size;
716 const int output_sample_count =
s->output_sample_count;
717 const int fsize =
s->frequency_band_count;
718 int *kernel_start =
s->kernel_start;
719 int *kernel_stop =
s->kernel_stop;
720 unsigned *
index =
s->index;
721 int range_min = INT_MAX;
722 int range_max = 0,
ret = 0;
729 for (
int y = 0; y <
fsize; y++) {
731 int start = INT_MIN, stop = INT_MAX;
732 const float frequency =
s->frequency_band[y*2];
733 const float deviation = 1.f / (
s->frequency_band[y*2+1] *
734 output_sample_count);
739 memset(tkernel, 0,
size *
sizeof(*tkernel));
740 for (
int n =
a; n <
b; n++) {
741 float ff,
f = n+0.5f-frequency;
743 ff =
expf(-
f*
f*deviation);
744 tkernel[n+
range] = ff;
747 for (
int n =
a; n <
b; n++) {
748 if (tkernel[n+
range] != 0.
f) {
749 if (tkernel[n+
range] > FLT_MIN)
756 for (
int n =
b; n >=
a; n--) {
757 if (tkernel[n+
range] != 0.
f) {
758 if (tkernel[n+
range] > FLT_MIN)
765 if (start == INT_MIN || stop == INT_MAX) {
770 kernel_start[y] = start;
771 kernel_stop[y] = stop;
779 for (
int n = 0; n <= stop - start; n++) {
780 kernel[n].
re = tkernel[n+
range+start];
781 kernel[n].
im = tkernel[n+
range+start];
784 range_min =
FFMIN(range_min, stop+1-start);
785 range_max =
FFMAX(range_max, stop+1-start);
787 s->kernel[y] = kernel;
790 for (
int n = 0; n <
size; n++)
791 index[n] = n & (
s->output_padding_size - 1);
807 const float limit_frequency =
inlink->sample_rate * 0.5f;
808 float maximum_frequency =
fminf(
s->maximum_frequency, limit_frequency);
809 float minimum_frequency =
s->minimum_frequency;
813 if (minimum_frequency >= maximum_frequency) {
815 minimum_frequency, maximum_frequency);
825 switch (
s->direction) {
828 s->bar_size =
s->w *
s->bar_ratio;
829 s->sono_size =
s->w -
s->bar_size;
830 s->frequency_band_count =
s->h;
834 s->bar_size =
s->h *
s->bar_ratio;
835 s->sono_size =
s->h -
s->bar_size;
836 s->frequency_band_count =
s->w;
840 switch (
s->frequency_scale) {
842 minimum_frequency = logf(minimum_frequency) / logf(2.
f);
843 maximum_frequency = logf(maximum_frequency) / logf(2.
f);
846 minimum_frequency = 6.f * asinhf(minimum_frequency / 600.
f);
847 maximum_frequency = 6.f * asinhf(maximum_frequency / 600.
f);
850 minimum_frequency = 2595.f *
log10f(1.
f + minimum_frequency / 700.
f);
851 maximum_frequency = 2595.f *
log10f(1.
f + maximum_frequency / 700.
f);
854 minimum_frequency = 11.17268f * logf(1.
f + (46.06538
f * minimum_frequency) / (minimum_frequency + 14678.49
f));
855 maximum_frequency = 11.17268f * logf(1.
f + (46.06538
f * maximum_frequency) / (maximum_frequency + 14678.49
f));
858 minimum_frequency =
sqrtf(minimum_frequency);
859 maximum_frequency =
sqrtf(maximum_frequency);
862 minimum_frequency =
cbrtf(minimum_frequency);
863 maximum_frequency =
cbrtf(maximum_frequency);
866 minimum_frequency =
powf(minimum_frequency, 0.25
f);
867 maximum_frequency =
powf(maximum_frequency, 0.25
f);
870 minimum_frequency =
powf(9.
f * (minimum_frequency * minimum_frequency) / 4.
f, 1.
f / 3.
f);
871 maximum_frequency =
powf(9.
f * (maximum_frequency * maximum_frequency) / 4.
f, 1.
f / 3.
f);
875 s->frequency_band =
av_calloc(
s->frequency_band_count,
876 sizeof(*
s->frequency_band) * 2);
877 if (!
s->frequency_band)
880 s->nb_consumed_samples =
inlink->sample_rate *
882 s->frequency_band_count, maximum_frequency - minimum_frequency,
883 minimum_frequency,
s->frequency_scale,
s->deviation);
884 s->nb_consumed_samples =
FFMIN(
s->nb_consumed_samples, 65536);
887 s->nb_channels =
inlink->ch_layout.nb_channels;
891 s->input_sample_count = 1 << (32 -
ff_clz(
s->nb_consumed_samples));
892 s->input_padding_size = 1 << (32 -
ff_clz(
s->input_sample_count));
894 s->output_padding_size = 1 << (32 -
ff_clz(
s->output_sample_count));
896 s->hop_size =
s->input_sample_count;
897 s->ihop_size =
s->output_padding_size >> 1;
910 for (
int n = 0; n <
s->nb_threads; n++) {
920 for (
int n = 0; n <
s->nb_threads; n++) {
931 s->kernel =
av_calloc(
s->frequency_band_count,
sizeof(*
s->kernel));
938 s->index =
av_calloc(
s->input_padding_size,
sizeof(*
s->index));
939 s->kernel_start =
av_calloc(
s->frequency_band_count,
sizeof(*
s->kernel_start));
940 s->kernel_stop =
av_calloc(
s->frequency_band_count,
sizeof(*
s->kernel_stop));
941 if (!
s->outpicref || !
s->fft_in || !
s->fft_out || !
s->src_x || !
s->dst_x || !
s->over ||
942 !
s->ifft_in || !
s->ifft_out || !
s->kernel_start || !
s->kernel_stop || !
s->ch_out ||
943 !
s->cache || !
s->index || !
s->bh_out || !
s->kernel)
946 s->ch_out->format =
inlink->format;
947 s->ch_out->nb_samples = 2 *
s->ihop_size *
inlink->ch_layout.nb_channels;
948 s->ch_out->ch_layout.nb_channels =
s->frequency_band_count;
953 s->ifft_in->format =
inlink->format;
954 s->ifft_in->nb_samples =
s->ifft_size * 2;
955 s->ifft_in->ch_layout.nb_channels =
s->nb_threads;
960 s->ifft_out->format =
inlink->format;
961 s->ifft_out->nb_samples =
s->ifft_size * 2;
962 s->ifft_out->ch_layout.nb_channels =
s->nb_threads;
967 s->src_x->format =
inlink->format;
968 s->src_x->nb_samples =
s->fft_size * 2;
969 s->src_x->ch_layout.nb_channels =
s->nb_threads;
974 s->dst_x->format =
inlink->format;
975 s->dst_x->nb_samples =
s->fft_size * 2;
976 s->dst_x->ch_layout.nb_channels =
s->nb_threads;
981 s->outpicref->sample_aspect_ratio = (
AVRational){1,1};
983 for (
int y = 0; y < outlink->
h; y++) {
984 memset(
s->outpicref->data[0] + y *
s->outpicref->linesize[0], 0, outlink->
w);
985 memset(
s->outpicref->data[1] + y *
s->outpicref->linesize[1], 128, outlink->
w);
986 memset(
s->outpicref->data[2] + y *
s->outpicref->linesize[2], 128, outlink->
w);
987 if (
s->outpicref->data[3])
988 memset(
s->outpicref->data[3] + y *
s->outpicref->linesize[3], 0, outlink->
w);
994 for (
int n = 0; n <
s->frequency_band_count; n++) {
995 s->frequency_band[2*n ] *=
factor;
996 s->frequency_band[2*n+1] *=
factor;
1008 switch (
s->direction) {
1011 s->pos =
s->bar_size;
1015 s->pos =
s->sono_size;
1020 if (strcmp(
s->rate_str,
"auto")) {
1025 s->frame_rate =
s->auto_frame_rate;
1042 const int nb_planes = 3 + (
s->outpicref->data[3] !=
NULL);
1047 switch (
s->direction) {
1049 for (
int p = 0; p < nb_planes; p++) {
1050 ptrdiff_t linesize =
s->outpicref->linesize[p];
1052 for (
int y =
s->h - 1; y >
s->bar_size; y--) {
1053 uint8_t *
dst =
s->outpicref->data[p] + y * linesize;
1055 memmove(
dst,
dst - linesize,
s->w);
1060 for (
int p = 0; p < nb_planes; p++) {
1061 ptrdiff_t linesize =
s->outpicref->linesize[p];
1063 for (
int y = 0; y <
s->sono_size; y++) {
1064 uint8_t *
dst =
s->outpicref->data[p] + y * linesize;
1066 memmove(
dst,
dst + linesize,
s->w);
1079 switch (
s->direction) {
1082 if (
s->pos >=
s->w) {
1083 s->pos =
s->bar_size;
1090 s->pos =
s->sono_size;
1096 if (
s->pos >=
s->h) {
1097 s->pos =
s->bar_size;
1104 s->pos =
s->sono_size;
1111 switch (
s->direction) {
1114 s->pos =
s->bar_size;
1118 s->pos =
s->sono_size;
1125 switch (
s->direction) {
1127 for (
int p = 0; p < nb_planes; p++) {
1128 ptrdiff_t linesize =
s->outpicref->linesize[p];
1129 const int size =
s->w -
s->pos;
1130 const int fill = p > 0 && p < 3 ? 128 : 0;
1131 const int x =
s->pos;
1133 for (
int y = 0; y <
s->h; y++) {
1134 uint8_t *
dst =
s->outpicref->data[p] + y * linesize + x;
1141 for (
int p = 0; p < nb_planes; p++) {
1142 ptrdiff_t linesize =
s->outpicref->linesize[p];
1143 const int size =
s->w -
s->pos;
1144 const int fill = p > 0 && p < 3 ? 128 : 0;
1146 for (
int y = 0; y <
s->h; y++) {
1147 uint8_t *
dst =
s->outpicref->data[p] + y * linesize;
1154 for (
int p = 0; p < nb_planes; p++) {
1155 ptrdiff_t linesize =
s->outpicref->linesize[p];
1156 const int fill = p > 0 && p < 3 ? 128 : 0;
1158 for (
int y =
s->pos; y < s->
h; y++) {
1159 uint8_t *
dst =
s->outpicref->data[p] + y * linesize;
1161 memset(
dst, fill,
s->w);
1166 for (
int p = 0; p < nb_planes; p++) {
1167 ptrdiff_t linesize =
s->outpicref->linesize[p];
1168 const int fill = p > 0 && p < 3 ? 128 : 0;
1170 for (
int y =
s->h -
s->pos; y >= 0; y--) {
1171 uint8_t *
dst =
s->outpicref->data[p] + y * linesize;
1173 memset(
dst, fill,
s->w);
1184 const int offset = (
s->input_padding_size -
s->hop_size) >> 1;
1188 s->outpicref->duration = 1;
1192 if (
s->ihop_index >=
s->ihop_size)
1193 s->ihop_index =
s->hop_index = 0;
1198 if (
s->old_pts <
s->outpicref->pts) {
1208 s->old_pts =
s->outpicref->pts;
1224 const int count =
s->nb_channels;
1225 const int start = (count * jobnr) / nb_jobs;
1226 const int end = (count * (jobnr+1)) / nb_jobs;
1228 for (
int ch = start; ch < end; ch++)
1247 if (
s->hop_index <
s->hop_size) {
1254 if (
ret > 0 ||
s->eof) {
1256 FFMIN(
s->nb_threads,
s->nb_channels));
1258 if (
s->hop_index == 0) {
1259 s->in_pts = fin->
pts;
1266 s->hop_index =
s->hop_size;
1271 if (
s->hop_index >=
s->hop_size ||
s->ihop_index > 0) {
1272 for (
int ch = 0; ch <
s->nb_channels &&
s->ihop_index == 0; ch++) {
1300 s->hop_index >=
s->hop_size ||
s->eof) {
1323 .description =
NULL_IF_CONFIG_SMALL(
"Convert input audio to a CWT (Continuous Wavelet Transform) spectrum video output."),
1330 .priv_class = &showcwt_class,