rematrix.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505
  1. /*
  2. * Copyright (C) 2011-2012 Michael Niedermayer (michaelni@gmx.at)
  3. *
  4. * This file is part of libswresample
  5. *
  6. * libswresample is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU Lesser General Public
  8. * License as published by the Free Software Foundation; either
  9. * version 2.1 of the License, or (at your option) any later version.
  10. *
  11. * libswresample is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * Lesser General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU Lesser General Public
  17. * License along with libswresample; if not, write to the Free Software
  18. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19. */
  20. #include "swresample_internal.h"
  21. #include "libavutil/avassert.h"
  22. #include "libavutil/channel_layout.h"
  23. #define TEMPLATE_REMATRIX_FLT
  24. #include "rematrix_template.c"
  25. #undef TEMPLATE_REMATRIX_FLT
  26. #define TEMPLATE_REMATRIX_DBL
  27. #include "rematrix_template.c"
  28. #undef TEMPLATE_REMATRIX_DBL
  29. #define TEMPLATE_REMATRIX_S16
  30. #include "rematrix_template.c"
  31. #undef TEMPLATE_REMATRIX_S16
  32. #define TEMPLATE_REMATRIX_S32
  33. #include "rematrix_template.c"
  34. #undef TEMPLATE_REMATRIX_S32
  35. #define FRONT_LEFT 0
  36. #define FRONT_RIGHT 1
  37. #define FRONT_CENTER 2
  38. #define LOW_FREQUENCY 3
  39. #define BACK_LEFT 4
  40. #define BACK_RIGHT 5
  41. #define FRONT_LEFT_OF_CENTER 6
  42. #define FRONT_RIGHT_OF_CENTER 7
  43. #define BACK_CENTER 8
  44. #define SIDE_LEFT 9
  45. #define SIDE_RIGHT 10
  46. #define TOP_CENTER 11
  47. #define TOP_FRONT_LEFT 12
  48. #define TOP_FRONT_CENTER 13
  49. #define TOP_FRONT_RIGHT 14
  50. #define TOP_BACK_LEFT 15
  51. #define TOP_BACK_CENTER 16
  52. #define TOP_BACK_RIGHT 17
  53. int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride)
  54. {
  55. int nb_in, nb_out, in, out;
  56. if (!s || s->in_convert) // s needs to be allocated but not initialized
  57. return AVERROR(EINVAL);
  58. memset(s->matrix, 0, sizeof(s->matrix));
  59. nb_in = av_get_channel_layout_nb_channels(s->in_ch_layout);
  60. nb_out = av_get_channel_layout_nb_channels(s->out_ch_layout);
  61. for (out = 0; out < nb_out; out++) {
  62. for (in = 0; in < nb_in; in++)
  63. s->matrix[out][in] = matrix[in];
  64. matrix += stride;
  65. }
  66. s->rematrix_custom = 1;
  67. return 0;
  68. }
  69. static int even(int64_t layout){
  70. if(!layout) return 1;
  71. if(layout&(layout-1)) return 1;
  72. return 0;
  73. }
  74. static int clean_layout(SwrContext *s, int64_t layout){
  75. if(layout && layout != AV_CH_FRONT_CENTER && !(layout&(layout-1))) {
  76. char buf[128];
  77. av_get_channel_layout_string(buf, sizeof(buf), -1, layout);
  78. av_log(s, AV_LOG_VERBOSE, "Treating %s as mono\n", buf);
  79. return AV_CH_FRONT_CENTER;
  80. }
  81. return layout;
  82. }
  83. static int sane_layout(int64_t layout){
  84. if(!(layout & AV_CH_LAYOUT_SURROUND)) // at least 1 front speaker
  85. return 0;
  86. if(!even(layout & (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT))) // no asymetric front
  87. return 0;
  88. if(!even(layout & (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT))) // no asymetric side
  89. return 0;
  90. if(!even(layout & (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)))
  91. return 0;
  92. if(!even(layout & (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)))
  93. return 0;
  94. if(av_get_channel_layout_nb_channels(layout) >= SWR_CH_MAX)
  95. return 0;
  96. return 1;
  97. }
  98. av_cold static int auto_matrix(SwrContext *s)
  99. {
  100. int i, j, out_i;
  101. double matrix[64][64]={{0}};
  102. int64_t unaccounted, in_ch_layout, out_ch_layout;
  103. double maxcoef=0;
  104. char buf[128];
  105. const int matrix_encoding = s->matrix_encoding;
  106. float maxval;
  107. in_ch_layout = clean_layout(s, s->in_ch_layout);
  108. out_ch_layout = clean_layout(s, s->out_ch_layout);
  109. if( out_ch_layout == AV_CH_LAYOUT_STEREO_DOWNMIX
  110. && (in_ch_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == 0
  111. )
  112. out_ch_layout = AV_CH_LAYOUT_STEREO;
  113. if( in_ch_layout == AV_CH_LAYOUT_STEREO_DOWNMIX
  114. && (out_ch_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == 0
  115. )
  116. in_ch_layout = AV_CH_LAYOUT_STEREO;
  117. if(!sane_layout(in_ch_layout)){
  118. av_get_channel_layout_string(buf, sizeof(buf), -1, s->in_ch_layout);
  119. av_log(s, AV_LOG_ERROR, "Input channel layout '%s' is not supported\n", buf);
  120. return AVERROR(EINVAL);
  121. }
  122. if(!sane_layout(out_ch_layout)){
  123. av_get_channel_layout_string(buf, sizeof(buf), -1, s->out_ch_layout);
  124. av_log(s, AV_LOG_ERROR, "Output channel layout '%s' is not supported\n", buf);
  125. return AVERROR(EINVAL);
  126. }
  127. memset(s->matrix, 0, sizeof(s->matrix));
  128. for(i=0; i<64; i++){
  129. if(in_ch_layout & out_ch_layout & (1ULL<<i))
  130. matrix[i][i]= 1.0;
  131. }
  132. unaccounted= in_ch_layout & ~out_ch_layout;
  133. //FIXME implement dolby surround
  134. //FIXME implement full ac3
  135. if(unaccounted & AV_CH_FRONT_CENTER){
  136. if((out_ch_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO){
  137. if(in_ch_layout & AV_CH_LAYOUT_STEREO) {
  138. matrix[ FRONT_LEFT][FRONT_CENTER]+= s->clev;
  139. matrix[FRONT_RIGHT][FRONT_CENTER]+= s->clev;
  140. } else {
  141. matrix[ FRONT_LEFT][FRONT_CENTER]+= M_SQRT1_2;
  142. matrix[FRONT_RIGHT][FRONT_CENTER]+= M_SQRT1_2;
  143. }
  144. }else
  145. av_assert0(0);
  146. }
  147. if(unaccounted & AV_CH_LAYOUT_STEREO){
  148. if(out_ch_layout & AV_CH_FRONT_CENTER){
  149. matrix[FRONT_CENTER][ FRONT_LEFT]+= M_SQRT1_2;
  150. matrix[FRONT_CENTER][FRONT_RIGHT]+= M_SQRT1_2;
  151. if(in_ch_layout & AV_CH_FRONT_CENTER)
  152. matrix[FRONT_CENTER][ FRONT_CENTER] = s->clev*sqrt(2);
  153. }else
  154. av_assert0(0);
  155. }
  156. if(unaccounted & AV_CH_BACK_CENTER){
  157. if(out_ch_layout & AV_CH_BACK_LEFT){
  158. matrix[ BACK_LEFT][BACK_CENTER]+= M_SQRT1_2;
  159. matrix[BACK_RIGHT][BACK_CENTER]+= M_SQRT1_2;
  160. }else if(out_ch_layout & AV_CH_SIDE_LEFT){
  161. matrix[ SIDE_LEFT][BACK_CENTER]+= M_SQRT1_2;
  162. matrix[SIDE_RIGHT][BACK_CENTER]+= M_SQRT1_2;
  163. }else if(out_ch_layout & AV_CH_FRONT_LEFT){
  164. if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY ||
  165. matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
  166. if (unaccounted & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT)) {
  167. matrix[FRONT_LEFT ][BACK_CENTER] -= s->slev * M_SQRT1_2;
  168. matrix[FRONT_RIGHT][BACK_CENTER] += s->slev * M_SQRT1_2;
  169. } else {
  170. matrix[FRONT_LEFT ][BACK_CENTER] -= s->slev;
  171. matrix[FRONT_RIGHT][BACK_CENTER] += s->slev;
  172. }
  173. } else {
  174. matrix[ FRONT_LEFT][BACK_CENTER]+= s->slev*M_SQRT1_2;
  175. matrix[FRONT_RIGHT][BACK_CENTER]+= s->slev*M_SQRT1_2;
  176. }
  177. }else if(out_ch_layout & AV_CH_FRONT_CENTER){
  178. matrix[ FRONT_CENTER][BACK_CENTER]+= s->slev*M_SQRT1_2;
  179. }else
  180. av_assert0(0);
  181. }
  182. if(unaccounted & AV_CH_BACK_LEFT){
  183. if(out_ch_layout & AV_CH_BACK_CENTER){
  184. matrix[BACK_CENTER][ BACK_LEFT]+= M_SQRT1_2;
  185. matrix[BACK_CENTER][BACK_RIGHT]+= M_SQRT1_2;
  186. }else if(out_ch_layout & AV_CH_SIDE_LEFT){
  187. if(in_ch_layout & AV_CH_SIDE_LEFT){
  188. matrix[ SIDE_LEFT][ BACK_LEFT]+= M_SQRT1_2;
  189. matrix[SIDE_RIGHT][BACK_RIGHT]+= M_SQRT1_2;
  190. }else{
  191. matrix[ SIDE_LEFT][ BACK_LEFT]+= 1.0;
  192. matrix[SIDE_RIGHT][BACK_RIGHT]+= 1.0;
  193. }
  194. }else if(out_ch_layout & AV_CH_FRONT_LEFT){
  195. if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
  196. matrix[FRONT_LEFT ][BACK_LEFT ] -= s->slev * M_SQRT1_2;
  197. matrix[FRONT_LEFT ][BACK_RIGHT] -= s->slev * M_SQRT1_2;
  198. matrix[FRONT_RIGHT][BACK_LEFT ] += s->slev * M_SQRT1_2;
  199. matrix[FRONT_RIGHT][BACK_RIGHT] += s->slev * M_SQRT1_2;
  200. } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
  201. matrix[FRONT_LEFT ][BACK_LEFT ] -= s->slev * SQRT3_2;
  202. matrix[FRONT_LEFT ][BACK_RIGHT] -= s->slev * M_SQRT1_2;
  203. matrix[FRONT_RIGHT][BACK_LEFT ] += s->slev * M_SQRT1_2;
  204. matrix[FRONT_RIGHT][BACK_RIGHT] += s->slev * SQRT3_2;
  205. } else {
  206. matrix[ FRONT_LEFT][ BACK_LEFT] += s->slev;
  207. matrix[FRONT_RIGHT][BACK_RIGHT] += s->slev;
  208. }
  209. }else if(out_ch_layout & AV_CH_FRONT_CENTER){
  210. matrix[ FRONT_CENTER][BACK_LEFT ]+= s->slev*M_SQRT1_2;
  211. matrix[ FRONT_CENTER][BACK_RIGHT]+= s->slev*M_SQRT1_2;
  212. }else
  213. av_assert0(0);
  214. }
  215. if(unaccounted & AV_CH_SIDE_LEFT){
  216. if(out_ch_layout & AV_CH_BACK_LEFT){
  217. /* if back channels do not exist in the input, just copy side
  218. channels to back channels, otherwise mix side into back */
  219. if (in_ch_layout & AV_CH_BACK_LEFT) {
  220. matrix[BACK_LEFT ][SIDE_LEFT ] += M_SQRT1_2;
  221. matrix[BACK_RIGHT][SIDE_RIGHT] += M_SQRT1_2;
  222. } else {
  223. matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
  224. matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
  225. }
  226. }else if(out_ch_layout & AV_CH_BACK_CENTER){
  227. matrix[BACK_CENTER][ SIDE_LEFT]+= M_SQRT1_2;
  228. matrix[BACK_CENTER][SIDE_RIGHT]+= M_SQRT1_2;
  229. }else if(out_ch_layout & AV_CH_FRONT_LEFT){
  230. if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
  231. matrix[FRONT_LEFT ][SIDE_LEFT ] -= s->slev * M_SQRT1_2;
  232. matrix[FRONT_LEFT ][SIDE_RIGHT] -= s->slev * M_SQRT1_2;
  233. matrix[FRONT_RIGHT][SIDE_LEFT ] += s->slev * M_SQRT1_2;
  234. matrix[FRONT_RIGHT][SIDE_RIGHT] += s->slev * M_SQRT1_2;
  235. } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
  236. matrix[FRONT_LEFT ][SIDE_LEFT ] -= s->slev * SQRT3_2;
  237. matrix[FRONT_LEFT ][SIDE_RIGHT] -= s->slev * M_SQRT1_2;
  238. matrix[FRONT_RIGHT][SIDE_LEFT ] += s->slev * M_SQRT1_2;
  239. matrix[FRONT_RIGHT][SIDE_RIGHT] += s->slev * SQRT3_2;
  240. } else {
  241. matrix[ FRONT_LEFT][ SIDE_LEFT] += s->slev;
  242. matrix[FRONT_RIGHT][SIDE_RIGHT] += s->slev;
  243. }
  244. }else if(out_ch_layout & AV_CH_FRONT_CENTER){
  245. matrix[ FRONT_CENTER][SIDE_LEFT ]+= s->slev*M_SQRT1_2;
  246. matrix[ FRONT_CENTER][SIDE_RIGHT]+= s->slev*M_SQRT1_2;
  247. }else
  248. av_assert0(0);
  249. }
  250. if(unaccounted & AV_CH_FRONT_LEFT_OF_CENTER){
  251. if(out_ch_layout & AV_CH_FRONT_LEFT){
  252. matrix[ FRONT_LEFT][ FRONT_LEFT_OF_CENTER]+= 1.0;
  253. matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER]+= 1.0;
  254. }else if(out_ch_layout & AV_CH_FRONT_CENTER){
  255. matrix[ FRONT_CENTER][ FRONT_LEFT_OF_CENTER]+= M_SQRT1_2;
  256. matrix[ FRONT_CENTER][FRONT_RIGHT_OF_CENTER]+= M_SQRT1_2;
  257. }else
  258. av_assert0(0);
  259. }
  260. /* mix LFE into front left/right or center */
  261. if (unaccounted & AV_CH_LOW_FREQUENCY) {
  262. if (out_ch_layout & AV_CH_FRONT_CENTER) {
  263. matrix[FRONT_CENTER][LOW_FREQUENCY] += s->lfe_mix_level;
  264. } else if (out_ch_layout & AV_CH_FRONT_LEFT) {
  265. matrix[FRONT_LEFT ][LOW_FREQUENCY] += s->lfe_mix_level * M_SQRT1_2;
  266. matrix[FRONT_RIGHT][LOW_FREQUENCY] += s->lfe_mix_level * M_SQRT1_2;
  267. } else
  268. av_assert0(0);
  269. }
  270. for(out_i=i=0; i<64; i++){
  271. double sum=0;
  272. int in_i=0;
  273. for(j=0; j<64; j++){
  274. s->matrix[out_i][in_i]= matrix[i][j];
  275. if(matrix[i][j]){
  276. sum += fabs(matrix[i][j]);
  277. }
  278. if(in_ch_layout & (1ULL<<j))
  279. in_i++;
  280. }
  281. maxcoef= FFMAX(maxcoef, sum);
  282. if(out_ch_layout & (1ULL<<i))
  283. out_i++;
  284. }
  285. if(s->rematrix_volume < 0)
  286. maxcoef = -s->rematrix_volume;
  287. if (s->rematrix_maxval > 0) {
  288. maxval = s->rematrix_maxval;
  289. } else if ( av_get_packed_sample_fmt(s->out_sample_fmt) < AV_SAMPLE_FMT_FLT
  290. || av_get_packed_sample_fmt(s->int_sample_fmt) < AV_SAMPLE_FMT_FLT) {
  291. maxval = 1.0;
  292. } else
  293. maxval = INT_MAX;
  294. if(maxcoef > maxval || s->rematrix_volume < 0){
  295. maxcoef /= maxval;
  296. for(i=0; i<SWR_CH_MAX; i++)
  297. for(j=0; j<SWR_CH_MAX; j++){
  298. s->matrix[i][j] /= maxcoef;
  299. }
  300. }
  301. if(s->rematrix_volume > 0){
  302. for(i=0; i<SWR_CH_MAX; i++)
  303. for(j=0; j<SWR_CH_MAX; j++){
  304. s->matrix[i][j] *= s->rematrix_volume;
  305. }
  306. }
  307. for(i=0; i<av_get_channel_layout_nb_channels(out_ch_layout); i++){
  308. for(j=0; j<av_get_channel_layout_nb_channels(in_ch_layout); j++){
  309. av_log(NULL, AV_LOG_DEBUG, "%f ", s->matrix[i][j]);
  310. }
  311. av_log(NULL, AV_LOG_DEBUG, "\n");
  312. }
  313. return 0;
  314. }
  315. av_cold int swri_rematrix_init(SwrContext *s){
  316. int i, j;
  317. int nb_in = av_get_channel_layout_nb_channels(s->in_ch_layout);
  318. int nb_out = av_get_channel_layout_nb_channels(s->out_ch_layout);
  319. s->mix_any_f = NULL;
  320. if (!s->rematrix_custom) {
  321. int r = auto_matrix(s);
  322. if (r)
  323. return r;
  324. }
  325. if (s->midbuf.fmt == AV_SAMPLE_FMT_S16P){
  326. s->native_matrix = av_calloc(nb_in * nb_out, sizeof(int));
  327. s->native_one = av_mallocz(sizeof(int));
  328. for (i = 0; i < nb_out; i++)
  329. for (j = 0; j < nb_in; j++)
  330. ((int*)s->native_matrix)[i * nb_in + j] = lrintf(s->matrix[i][j] * 32768);
  331. *((int*)s->native_one) = 32768;
  332. s->mix_1_1_f = (mix_1_1_func_type*)copy_s16;
  333. s->mix_2_1_f = (mix_2_1_func_type*)sum2_s16;
  334. s->mix_any_f = (mix_any_func_type*)get_mix_any_func_s16(s);
  335. }else if(s->midbuf.fmt == AV_SAMPLE_FMT_FLTP){
  336. s->native_matrix = av_calloc(nb_in * nb_out, sizeof(float));
  337. s->native_one = av_mallocz(sizeof(float));
  338. for (i = 0; i < nb_out; i++)
  339. for (j = 0; j < nb_in; j++)
  340. ((float*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
  341. *((float*)s->native_one) = 1.0;
  342. s->mix_1_1_f = (mix_1_1_func_type*)copy_float;
  343. s->mix_2_1_f = (mix_2_1_func_type*)sum2_float;
  344. s->mix_any_f = (mix_any_func_type*)get_mix_any_func_float(s);
  345. }else if(s->midbuf.fmt == AV_SAMPLE_FMT_DBLP){
  346. s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));
  347. s->native_one = av_mallocz(sizeof(double));
  348. for (i = 0; i < nb_out; i++)
  349. for (j = 0; j < nb_in; j++)
  350. ((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
  351. *((double*)s->native_one) = 1.0;
  352. s->mix_1_1_f = (mix_1_1_func_type*)copy_double;
  353. s->mix_2_1_f = (mix_2_1_func_type*)sum2_double;
  354. s->mix_any_f = (mix_any_func_type*)get_mix_any_func_double(s);
  355. }else if(s->midbuf.fmt == AV_SAMPLE_FMT_S32P){
  356. // Only for dithering currently
  357. // s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));
  358. s->native_one = av_mallocz(sizeof(int));
  359. // for (i = 0; i < nb_out; i++)
  360. // for (j = 0; j < nb_in; j++)
  361. // ((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
  362. *((int*)s->native_one) = 32768;
  363. s->mix_1_1_f = (mix_1_1_func_type*)copy_s32;
  364. s->mix_2_1_f = (mix_2_1_func_type*)sum2_s32;
  365. s->mix_any_f = (mix_any_func_type*)get_mix_any_func_s32(s);
  366. }else
  367. av_assert0(0);
  368. //FIXME quantize for integeres
  369. for (i = 0; i < SWR_CH_MAX; i++) {
  370. int ch_in=0;
  371. for (j = 0; j < SWR_CH_MAX; j++) {
  372. s->matrix32[i][j]= lrintf(s->matrix[i][j] * 32768);
  373. if(s->matrix[i][j])
  374. s->matrix_ch[i][++ch_in]= j;
  375. }
  376. s->matrix_ch[i][0]= ch_in;
  377. }
  378. if(HAVE_YASM && HAVE_MMX) swri_rematrix_init_x86(s);
  379. return 0;
  380. }
  381. av_cold void swri_rematrix_free(SwrContext *s){
  382. av_freep(&s->native_matrix);
  383. av_freep(&s->native_one);
  384. av_freep(&s->native_simd_matrix);
  385. av_freep(&s->native_simd_one);
  386. }
  387. int swri_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy){
  388. int out_i, in_i, i, j;
  389. int len1 = 0;
  390. int off = 0;
  391. if(s->mix_any_f) {
  392. s->mix_any_f(out->ch, (const uint8_t **)in->ch, s->native_matrix, len);
  393. return 0;
  394. }
  395. if(s->mix_2_1_simd || s->mix_1_1_simd){
  396. len1= len&~15;
  397. off = len1 * out->bps;
  398. }
  399. av_assert0(!s->out_ch_layout || out->ch_count == av_get_channel_layout_nb_channels(s->out_ch_layout));
  400. av_assert0(!s-> in_ch_layout || in ->ch_count == av_get_channel_layout_nb_channels(s-> in_ch_layout));
  401. for(out_i=0; out_i<out->ch_count; out_i++){
  402. switch(s->matrix_ch[out_i][0]){
  403. case 0:
  404. if(mustcopy)
  405. memset(out->ch[out_i], 0, len * av_get_bytes_per_sample(s->int_sample_fmt));
  406. break;
  407. case 1:
  408. in_i= s->matrix_ch[out_i][1];
  409. if(s->matrix[out_i][in_i]!=1.0){
  410. if(s->mix_1_1_simd && len1)
  411. s->mix_1_1_simd(out->ch[out_i] , in->ch[in_i] , s->native_simd_matrix, in->ch_count*out_i + in_i, len1);
  412. if(len != len1)
  413. s->mix_1_1_f (out->ch[out_i]+off, in->ch[in_i]+off, s->native_matrix, in->ch_count*out_i + in_i, len-len1);
  414. }else if(mustcopy){
  415. memcpy(out->ch[out_i], in->ch[in_i], len*out->bps);
  416. }else{
  417. out->ch[out_i]= in->ch[in_i];
  418. }
  419. break;
  420. case 2: {
  421. int in_i1 = s->matrix_ch[out_i][1];
  422. int in_i2 = s->matrix_ch[out_i][2];
  423. if(s->mix_2_1_simd && len1)
  424. s->mix_2_1_simd(out->ch[out_i] , in->ch[in_i1] , in->ch[in_i2] , s->native_simd_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len1);
  425. else
  426. s->mix_2_1_f (out->ch[out_i] , in->ch[in_i1] , in->ch[in_i2] , s->native_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len1);
  427. if(len != len1)
  428. s->mix_2_1_f (out->ch[out_i]+off, in->ch[in_i1]+off, in->ch[in_i2]+off, s->native_matrix, in->ch_count*out_i + in_i1, in->ch_count*out_i + in_i2, len-len1);
  429. break;}
  430. default:
  431. if(s->int_sample_fmt == AV_SAMPLE_FMT_FLTP){
  432. for(i=0; i<len; i++){
  433. float v=0;
  434. for(j=0; j<s->matrix_ch[out_i][0]; j++){
  435. in_i= s->matrix_ch[out_i][1+j];
  436. v+= ((float*)in->ch[in_i])[i] * s->matrix[out_i][in_i];
  437. }
  438. ((float*)out->ch[out_i])[i]= v;
  439. }
  440. }else if(s->int_sample_fmt == AV_SAMPLE_FMT_DBLP){
  441. for(i=0; i<len; i++){
  442. double v=0;
  443. for(j=0; j<s->matrix_ch[out_i][0]; j++){
  444. in_i= s->matrix_ch[out_i][1+j];
  445. v+= ((double*)in->ch[in_i])[i] * s->matrix[out_i][in_i];
  446. }
  447. ((double*)out->ch[out_i])[i]= v;
  448. }
  449. }else{
  450. for(i=0; i<len; i++){
  451. int v=0;
  452. for(j=0; j<s->matrix_ch[out_i][0]; j++){
  453. in_i= s->matrix_ch[out_i][1+j];
  454. v+= ((int16_t*)in->ch[in_i])[i] * s->matrix32[out_i][in_i];
  455. }
  456. ((int16_t*)out->ch[out_i])[i]= (v + 16384)>>15;
  457. }
  458. }
  459. }
  460. }
  461. return 0;
  462. }