FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rematrix.c
Go to the documentation of this file.
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 
21 #include "swresample_internal.h"
22 #include "libavutil/avassert.h"
24 
25 #define TEMPLATE_REMATRIX_FLT
26 #include "rematrix_template.c"
27 #undef TEMPLATE_REMATRIX_FLT
28 
29 #define TEMPLATE_REMATRIX_DBL
30 #include "rematrix_template.c"
31 #undef TEMPLATE_REMATRIX_DBL
32 
33 #define TEMPLATE_REMATRIX_S16
34 #include "rematrix_template.c"
35 #undef TEMPLATE_REMATRIX_S16
36 
37 #define TEMPLATE_REMATRIX_S32
38 #include "rematrix_template.c"
39 #undef TEMPLATE_REMATRIX_S32
40 
41 #define FRONT_LEFT 0
42 #define FRONT_RIGHT 1
43 #define FRONT_CENTER 2
44 #define LOW_FREQUENCY 3
45 #define BACK_LEFT 4
46 #define BACK_RIGHT 5
47 #define FRONT_LEFT_OF_CENTER 6
48 #define FRONT_RIGHT_OF_CENTER 7
49 #define BACK_CENTER 8
50 #define SIDE_LEFT 9
51 #define SIDE_RIGHT 10
52 #define TOP_CENTER 11
53 #define TOP_FRONT_LEFT 12
54 #define TOP_FRONT_CENTER 13
55 #define TOP_FRONT_RIGHT 14
56 #define TOP_BACK_LEFT 15
57 #define TOP_BACK_CENTER 16
58 #define TOP_BACK_RIGHT 17
59 #define NUM_NAMED_CHANNELS 18
60 
61 int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride)
62 {
63  int nb_in, nb_out, in, out;
64 
65  if (!s || s->in_convert) // s needs to be allocated but not initialized
66  return AVERROR(EINVAL);
67  memset(s->matrix, 0, sizeof(s->matrix));
70  for (out = 0; out < nb_out; out++) {
71  for (in = 0; in < nb_in; in++)
72  s->matrix[out][in] = matrix[in];
73  matrix += stride;
74  }
75  s->rematrix_custom = 1;
76  return 0;
77 }
78 
79 static int even(int64_t layout){
80  if(!layout) return 1;
81  if(layout&(layout-1)) return 1;
82  return 0;
83 }
84 
85 static int clean_layout(SwrContext *s, int64_t layout){
86  if(layout && layout != AV_CH_FRONT_CENTER && !(layout&(layout-1))) {
87  char buf[128];
88  av_get_channel_layout_string(buf, sizeof(buf), -1, layout);
89  av_log(s, AV_LOG_VERBOSE, "Treating %s as mono\n", buf);
90  return AV_CH_FRONT_CENTER;
91  }
92 
93  return layout;
94 }
95 
96 static int sane_layout(int64_t layout){
97  if(!(layout & AV_CH_LAYOUT_SURROUND)) // at least 1 front speaker
98  return 0;
99  if(!even(layout & (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT))) // no asymetric front
100  return 0;
101  if(!even(layout & (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT))) // no asymetric side
102  return 0;
103  if(!even(layout & (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)))
104  return 0;
106  return 0;
108  return 0;
109 
110  return 1;
111 }
112 
114 {
115  int i, j, out_i;
116  double matrix[NUM_NAMED_CHANNELS][NUM_NAMED_CHANNELS]={{0}};
117  int64_t unaccounted, in_ch_layout, out_ch_layout;
118  double maxcoef=0;
119  char buf[128];
120  const int matrix_encoding = s->matrix_encoding;
121  float maxval;
122 
123  in_ch_layout = clean_layout(s, s->in_ch_layout);
124  out_ch_layout = clean_layout(s, s->out_ch_layout);
125 
126  if( out_ch_layout == AV_CH_LAYOUT_STEREO_DOWNMIX
127  && (in_ch_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == 0
128  )
129  out_ch_layout = AV_CH_LAYOUT_STEREO;
130 
131  if( in_ch_layout == AV_CH_LAYOUT_STEREO_DOWNMIX
132  && (out_ch_layout & AV_CH_LAYOUT_STEREO_DOWNMIX) == 0
133  )
134  in_ch_layout = AV_CH_LAYOUT_STEREO;
135 
136  if(!sane_layout(in_ch_layout)){
137  av_get_channel_layout_string(buf, sizeof(buf), -1, s->in_ch_layout);
138  av_log(s, AV_LOG_ERROR, "Input channel layout '%s' is not supported\n", buf);
139  return AVERROR(EINVAL);
140  }
141 
142  if(!sane_layout(out_ch_layout)){
143  av_get_channel_layout_string(buf, sizeof(buf), -1, s->out_ch_layout);
144  av_log(s, AV_LOG_ERROR, "Output channel layout '%s' is not supported\n", buf);
145  return AVERROR(EINVAL);
146  }
147 
148  memset(s->matrix, 0, sizeof(s->matrix));
149  for(i=0; i<FF_ARRAY_ELEMS(matrix); i++){
150  if(in_ch_layout & out_ch_layout & (1ULL<<i))
151  matrix[i][i]= 1.0;
152  }
153 
154  unaccounted= in_ch_layout & ~out_ch_layout;
155 
156 //FIXME implement dolby surround
157 //FIXME implement full ac3
158 
159 
160  if(unaccounted & AV_CH_FRONT_CENTER){
161  if((out_ch_layout & AV_CH_LAYOUT_STEREO) == AV_CH_LAYOUT_STEREO){
162  if(in_ch_layout & AV_CH_LAYOUT_STEREO) {
163  matrix[ FRONT_LEFT][FRONT_CENTER]+= s->clev;
164  matrix[FRONT_RIGHT][FRONT_CENTER]+= s->clev;
165  } else {
166  matrix[ FRONT_LEFT][FRONT_CENTER]+= M_SQRT1_2;
168  }
169  }else
170  av_assert0(0);
171  }
172  if(unaccounted & AV_CH_LAYOUT_STEREO){
173  if(out_ch_layout & AV_CH_FRONT_CENTER){
174  matrix[FRONT_CENTER][ FRONT_LEFT]+= M_SQRT1_2;
176  if(in_ch_layout & AV_CH_FRONT_CENTER)
177  matrix[FRONT_CENTER][ FRONT_CENTER] = s->clev*sqrt(2);
178  }else
179  av_assert0(0);
180  }
181 
182  if(unaccounted & AV_CH_BACK_CENTER){
183  if(out_ch_layout & AV_CH_BACK_LEFT){
184  matrix[ BACK_LEFT][BACK_CENTER]+= M_SQRT1_2;
185  matrix[BACK_RIGHT][BACK_CENTER]+= M_SQRT1_2;
186  }else if(out_ch_layout & AV_CH_SIDE_LEFT){
187  matrix[ SIDE_LEFT][BACK_CENTER]+= M_SQRT1_2;
188  matrix[SIDE_RIGHT][BACK_CENTER]+= M_SQRT1_2;
189  }else if(out_ch_layout & AV_CH_FRONT_LEFT){
190  if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY ||
191  matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
192  if (unaccounted & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT)) {
193  matrix[FRONT_LEFT ][BACK_CENTER] -= s->slev * M_SQRT1_2;
194  matrix[FRONT_RIGHT][BACK_CENTER] += s->slev * M_SQRT1_2;
195  } else {
196  matrix[FRONT_LEFT ][BACK_CENTER] -= s->slev;
197  matrix[FRONT_RIGHT][BACK_CENTER] += s->slev;
198  }
199  } else {
200  matrix[ FRONT_LEFT][BACK_CENTER]+= s->slev*M_SQRT1_2;
201  matrix[FRONT_RIGHT][BACK_CENTER]+= s->slev*M_SQRT1_2;
202  }
203  }else if(out_ch_layout & AV_CH_FRONT_CENTER){
204  matrix[ FRONT_CENTER][BACK_CENTER]+= s->slev*M_SQRT1_2;
205  }else
206  av_assert0(0);
207  }
208  if(unaccounted & AV_CH_BACK_LEFT){
209  if(out_ch_layout & AV_CH_BACK_CENTER){
210  matrix[BACK_CENTER][ BACK_LEFT]+= M_SQRT1_2;
211  matrix[BACK_CENTER][BACK_RIGHT]+= M_SQRT1_2;
212  }else if(out_ch_layout & AV_CH_SIDE_LEFT){
213  if(in_ch_layout & AV_CH_SIDE_LEFT){
214  matrix[ SIDE_LEFT][ BACK_LEFT]+= M_SQRT1_2;
215  matrix[SIDE_RIGHT][BACK_RIGHT]+= M_SQRT1_2;
216  }else{
217  matrix[ SIDE_LEFT][ BACK_LEFT]+= 1.0;
218  matrix[SIDE_RIGHT][BACK_RIGHT]+= 1.0;
219  }
220  }else if(out_ch_layout & AV_CH_FRONT_LEFT){
221  if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
222  matrix[FRONT_LEFT ][BACK_LEFT ] -= s->slev * M_SQRT1_2;
223  matrix[FRONT_LEFT ][BACK_RIGHT] -= s->slev * M_SQRT1_2;
224  matrix[FRONT_RIGHT][BACK_LEFT ] += s->slev * M_SQRT1_2;
225  matrix[FRONT_RIGHT][BACK_RIGHT] += s->slev * M_SQRT1_2;
226  } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
227  matrix[FRONT_LEFT ][BACK_LEFT ] -= s->slev * SQRT3_2;
228  matrix[FRONT_LEFT ][BACK_RIGHT] -= s->slev * M_SQRT1_2;
229  matrix[FRONT_RIGHT][BACK_LEFT ] += s->slev * M_SQRT1_2;
230  matrix[FRONT_RIGHT][BACK_RIGHT] += s->slev * SQRT3_2;
231  } else {
232  matrix[ FRONT_LEFT][ BACK_LEFT] += s->slev;
233  matrix[FRONT_RIGHT][BACK_RIGHT] += s->slev;
234  }
235  }else if(out_ch_layout & AV_CH_FRONT_CENTER){
236  matrix[ FRONT_CENTER][BACK_LEFT ]+= s->slev*M_SQRT1_2;
237  matrix[ FRONT_CENTER][BACK_RIGHT]+= s->slev*M_SQRT1_2;
238  }else
239  av_assert0(0);
240  }
241 
242  if(unaccounted & AV_CH_SIDE_LEFT){
243  if(out_ch_layout & AV_CH_BACK_LEFT){
244  /* if back channels do not exist in the input, just copy side
245  channels to back channels, otherwise mix side into back */
246  if (in_ch_layout & AV_CH_BACK_LEFT) {
247  matrix[BACK_LEFT ][SIDE_LEFT ] += M_SQRT1_2;
248  matrix[BACK_RIGHT][SIDE_RIGHT] += M_SQRT1_2;
249  } else {
250  matrix[BACK_LEFT ][SIDE_LEFT ] += 1.0;
251  matrix[BACK_RIGHT][SIDE_RIGHT] += 1.0;
252  }
253  }else if(out_ch_layout & AV_CH_BACK_CENTER){
254  matrix[BACK_CENTER][ SIDE_LEFT]+= M_SQRT1_2;
255  matrix[BACK_CENTER][SIDE_RIGHT]+= M_SQRT1_2;
256  }else if(out_ch_layout & AV_CH_FRONT_LEFT){
257  if (matrix_encoding == AV_MATRIX_ENCODING_DOLBY) {
258  matrix[FRONT_LEFT ][SIDE_LEFT ] -= s->slev * M_SQRT1_2;
259  matrix[FRONT_LEFT ][SIDE_RIGHT] -= s->slev * M_SQRT1_2;
260  matrix[FRONT_RIGHT][SIDE_LEFT ] += s->slev * M_SQRT1_2;
261  matrix[FRONT_RIGHT][SIDE_RIGHT] += s->slev * M_SQRT1_2;
262  } else if (matrix_encoding == AV_MATRIX_ENCODING_DPLII) {
263  matrix[FRONT_LEFT ][SIDE_LEFT ] -= s->slev * SQRT3_2;
264  matrix[FRONT_LEFT ][SIDE_RIGHT] -= s->slev * M_SQRT1_2;
265  matrix[FRONT_RIGHT][SIDE_LEFT ] += s->slev * M_SQRT1_2;
266  matrix[FRONT_RIGHT][SIDE_RIGHT] += s->slev * SQRT3_2;
267  } else {
268  matrix[ FRONT_LEFT][ SIDE_LEFT] += s->slev;
269  matrix[FRONT_RIGHT][SIDE_RIGHT] += s->slev;
270  }
271  }else if(out_ch_layout & AV_CH_FRONT_CENTER){
272  matrix[ FRONT_CENTER][SIDE_LEFT ]+= s->slev*M_SQRT1_2;
273  matrix[ FRONT_CENTER][SIDE_RIGHT]+= s->slev*M_SQRT1_2;
274  }else
275  av_assert0(0);
276  }
277 
278  if(unaccounted & AV_CH_FRONT_LEFT_OF_CENTER){
279  if(out_ch_layout & AV_CH_FRONT_LEFT){
280  matrix[ FRONT_LEFT][ FRONT_LEFT_OF_CENTER]+= 1.0;
281  matrix[FRONT_RIGHT][FRONT_RIGHT_OF_CENTER]+= 1.0;
282  }else if(out_ch_layout & AV_CH_FRONT_CENTER){
285  }else
286  av_assert0(0);
287  }
288  /* mix LFE into front left/right or center */
289  if (unaccounted & AV_CH_LOW_FREQUENCY) {
290  if (out_ch_layout & AV_CH_FRONT_CENTER) {
292  } else if (out_ch_layout & AV_CH_FRONT_LEFT) {
295  } else
296  av_assert0(0);
297  }
298 
299  for(out_i=i=0; i<64; i++){
300  double sum=0;
301  int in_i=0;
302  if((out_ch_layout & (1ULL<<i)) == 0)
303  continue;
304  for(j=0; j<64; j++){
305  if((in_ch_layout & (1ULL<<j)) == 0)
306  continue;
307  if (i < FF_ARRAY_ELEMS(matrix) && j < FF_ARRAY_ELEMS(matrix[0]))
308  s->matrix[out_i][in_i]= matrix[i][j];
309  else
310  s->matrix[out_i][in_i]= i == j && (in_ch_layout & out_ch_layout & (1ULL<<i));
311  sum += fabs(s->matrix[out_i][in_i]);
312  in_i++;
313  }
314  maxcoef= FFMAX(maxcoef, sum);
315  out_i++;
316  }
317  if(s->rematrix_volume < 0)
318  maxcoef = -s->rematrix_volume;
319 
320  if (s->rematrix_maxval > 0) {
321  maxval = s->rematrix_maxval;
324  maxval = 1.0;
325  } else
326  maxval = INT_MAX;
327 
328  if(maxcoef > maxval || s->rematrix_volume < 0){
329  maxcoef /= maxval;
330  for(i=0; i<SWR_CH_MAX; i++)
331  for(j=0; j<SWR_CH_MAX; j++){
332  s->matrix[i][j] /= maxcoef;
333  }
334  }
335 
336  if(s->rematrix_volume > 0){
337  for(i=0; i<SWR_CH_MAX; i++)
338  for(j=0; j<SWR_CH_MAX; j++){
339  s->matrix[i][j] *= s->rematrix_volume;
340  }
341  }
342 
343  av_log(s, AV_LOG_DEBUG, "Matrix coefficients:\n");
344  for(i=0; i<av_get_channel_layout_nb_channels(out_ch_layout); i++){
345  const char *c =
347  av_log(s, AV_LOG_DEBUG, "%s: ", c ? c : "?");
348  for(j=0; j<av_get_channel_layout_nb_channels(in_ch_layout); j++){
350  av_log(s, AV_LOG_DEBUG, "%s:%f ", c ? c : "?", s->matrix[i][j]);
351  }
352  av_log(s, AV_LOG_DEBUG, "\n");
353  }
354  return 0;
355 }
356 
358  int i, j;
361 
362  s->mix_any_f = NULL;
363 
364  if (!s->rematrix_custom) {
365  int r = auto_matrix(s);
366  if (r)
367  return r;
368  }
369  if (s->midbuf.fmt == AV_SAMPLE_FMT_S16P){
370  s->native_matrix = av_calloc(nb_in * nb_out, sizeof(int));
371  s->native_one = av_mallocz(sizeof(int));
372  if (!s->native_matrix || !s->native_one)
373  return AVERROR(ENOMEM);
374  for (i = 0; i < nb_out; i++)
375  for (j = 0; j < nb_in; j++)
376  ((int*)s->native_matrix)[i * nb_in + j] = lrintf(s->matrix[i][j] * 32768);
377  *((int*)s->native_one) = 32768;
378  s->mix_1_1_f = (mix_1_1_func_type*)copy_s16;
379  s->mix_2_1_f = (mix_2_1_func_type*)sum2_s16;
380  s->mix_any_f = (mix_any_func_type*)get_mix_any_func_s16(s);
381  }else if(s->midbuf.fmt == AV_SAMPLE_FMT_FLTP){
382  s->native_matrix = av_calloc(nb_in * nb_out, sizeof(float));
383  s->native_one = av_mallocz(sizeof(float));
384  if (!s->native_matrix || !s->native_one)
385  return AVERROR(ENOMEM);
386  for (i = 0; i < nb_out; i++)
387  for (j = 0; j < nb_in; j++)
388  ((float*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
389  *((float*)s->native_one) = 1.0;
390  s->mix_1_1_f = (mix_1_1_func_type*)copy_float;
391  s->mix_2_1_f = (mix_2_1_func_type*)sum2_float;
392  s->mix_any_f = (mix_any_func_type*)get_mix_any_func_float(s);
393  }else if(s->midbuf.fmt == AV_SAMPLE_FMT_DBLP){
394  s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));
395  s->native_one = av_mallocz(sizeof(double));
396  if (!s->native_matrix || !s->native_one)
397  return AVERROR(ENOMEM);
398  for (i = 0; i < nb_out; i++)
399  for (j = 0; j < nb_in; j++)
400  ((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
401  *((double*)s->native_one) = 1.0;
402  s->mix_1_1_f = (mix_1_1_func_type*)copy_double;
403  s->mix_2_1_f = (mix_2_1_func_type*)sum2_double;
404  s->mix_any_f = (mix_any_func_type*)get_mix_any_func_double(s);
405  }else if(s->midbuf.fmt == AV_SAMPLE_FMT_S32P){
406  // Only for dithering currently
407 // s->native_matrix = av_calloc(nb_in * nb_out, sizeof(double));
408  s->native_one = av_mallocz(sizeof(int));
409  if (!s->native_one)
410  return AVERROR(ENOMEM);
411 // for (i = 0; i < nb_out; i++)
412 // for (j = 0; j < nb_in; j++)
413 // ((double*)s->native_matrix)[i * nb_in + j] = s->matrix[i][j];
414  *((int*)s->native_one) = 32768;
415  s->mix_1_1_f = (mix_1_1_func_type*)copy_s32;
416  s->mix_2_1_f = (mix_2_1_func_type*)sum2_s32;
417  s->mix_any_f = (mix_any_func_type*)get_mix_any_func_s32(s);
418  }else
419  av_assert0(0);
420  //FIXME quantize for integeres
421  for (i = 0; i < SWR_CH_MAX; i++) {
422  int ch_in=0;
423  for (j = 0; j < SWR_CH_MAX; j++) {
424  s->matrix32[i][j]= lrintf(s->matrix[i][j] * 32768);
425  if(s->matrix[i][j])
426  s->matrix_ch[i][++ch_in]= j;
427  }
428  s->matrix_ch[i][0]= ch_in;
429  }
430 
431  if(HAVE_YASM && HAVE_MMX)
432  return swri_rematrix_init_x86(s);
433 
434  return 0;
435 }
436 
438  av_freep(&s->native_matrix);
439  av_freep(&s->native_one);
442 }
443 
444 int swri_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy){
445  int out_i, in_i, i, j;
446  int len1 = 0;
447  int off = 0;
448 
449  if(s->mix_any_f) {
450  s->mix_any_f(out->ch, (const uint8_t **)in->ch, s->native_matrix, len);
451  return 0;
452  }
453 
454  if(s->mix_2_1_simd || s->mix_1_1_simd){
455  len1= len&~15;
456  off = len1 * out->bps;
457  }
458 
460  av_assert0(!s-> in_ch_layout || in ->ch_count == av_get_channel_layout_nb_channels(s-> in_ch_layout));
461 
462  for(out_i=0; out_i<out->ch_count; out_i++){
463  switch(s->matrix_ch[out_i][0]){
464  case 0:
465  if(mustcopy)
466  memset(out->ch[out_i], 0, len * av_get_bytes_per_sample(s->int_sample_fmt));
467  break;
468  case 1:
469  in_i= s->matrix_ch[out_i][1];
470  if(s->matrix[out_i][in_i]!=1.0){
471  if(s->mix_1_1_simd && len1)
472  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);
473  if(len != len1)
474  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);
475  }else if(mustcopy){
476  memcpy(out->ch[out_i], in->ch[in_i], len*out->bps);
477  }else{
478  out->ch[out_i]= in->ch[in_i];
479  }
480  break;
481  case 2: {
482  int in_i1 = s->matrix_ch[out_i][1];
483  int in_i2 = s->matrix_ch[out_i][2];
484  if(s->mix_2_1_simd && len1)
485  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);
486  else
487  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);
488  if(len != len1)
489  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);
490  break;}
491  default:
493  for(i=0; i<len; i++){
494  float v=0;
495  for(j=0; j<s->matrix_ch[out_i][0]; j++){
496  in_i= s->matrix_ch[out_i][1+j];
497  v+= ((float*)in->ch[in_i])[i] * s->matrix[out_i][in_i];
498  }
499  ((float*)out->ch[out_i])[i]= v;
500  }
501  }else if(s->int_sample_fmt == AV_SAMPLE_FMT_DBLP){
502  for(i=0; i<len; i++){
503  double v=0;
504  for(j=0; j<s->matrix_ch[out_i][0]; j++){
505  in_i= s->matrix_ch[out_i][1+j];
506  v+= ((double*)in->ch[in_i])[i] * s->matrix[out_i][in_i];
507  }
508  ((double*)out->ch[out_i])[i]= v;
509  }
510  }else{
511  for(i=0; i<len; i++){
512  int v=0;
513  for(j=0; j<s->matrix_ch[out_i][0]; j++){
514  in_i= s->matrix_ch[out_i][1+j];
515  v+= ((int16_t*)in->ch[in_i])[i] * s->matrix32[out_i][in_i];
516  }
517  ((int16_t*)out->ch[out_i])[i]= (v + 16384)>>15;
518  }
519  }
520  }
521  }
522  return 0;
523 }
float, planar
Definition: samplefmt.h:69
struct AudioConvert * in_convert
input conversion context
#define NULL
Definition: coverity.c:32
#define BACK_RIGHT
Definition: rematrix.c:46
const char * s
Definition: avisynth_c.h:631
#define FRONT_RIGHT
Definition: rematrix.c:42
enum AVSampleFormat int_sample_fmt
internal sample format (AV_SAMPLE_FMT_FLTP or AV_SAMPLE_FMT_S16P)
Audio buffer used for intermediate storage between conversion phases.
Definition: audio_data.h:37
#define FRONT_RIGHT_OF_CENTER
Definition: rematrix.c:48
#define AV_CH_LAYOUT_SURROUND
int ch_count
number of channels
void( mix_2_1_func_type)(void *out, const void *in1, const void *in2, void *coeffp, integer index1, integer index2, integer len)
#define SWR_CH_MAX
Definition: af_amerge.c:35
#define M_SQRT1_2
Definition: mathematics.h:52
int rematrix_custom
flag to indicate that a custom matrix has been defined
int swri_rematrix(SwrContext *s, AudioData *out, AudioData *in, int len, int mustcopy)
Definition: rematrix.c:444
double, planar
Definition: samplefmt.h:70
void( mix_1_1_func_type)(void *out, const void *in, void *coeffp, integer index, integer len)
#define LOW_FREQUENCY
Definition: rematrix.c:44
#define AV_CH_LAYOUT_STEREO
#define SQRT3_2
#define SIDE_RIGHT
Definition: rematrix.c:51
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_cold int swri_rematrix_init(SwrContext *s)
Definition: rematrix.c:357
uint8_t
#define av_cold
Definition: attributes.h:82
enum AVSampleFormat fmt
sample format
#define BACK_CENTER
Definition: rematrix.c:49
#define AV_CH_LOW_FREQUENCY
uint8_t * native_simd_one
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define lrintf(x)
Definition: libm_mips.h:70
#define AV_CH_BACK_LEFT
enum AVSampleFormat out_sample_fmt
output sample format
#define av_log(a,...)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int matrix_encoding
matrixed stereo encoding
float slev
surround mixing level
#define FRONT_CENTER
Definition: rematrix.c:43
#define AVERROR(e)
Definition: error.h:43
int64_t user_in_ch_layout
User set input channel layout.
The libswresample context.
#define SIDE_LEFT
Definition: rematrix.c:50
int swri_rematrix_init_x86(struct SwrContext *s)
const char * r
Definition: vf_curves.c:107
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
float clev
center mixing level
simple assert() macros that are a bit more flexible than ISO C assert().
mix_2_1_func_type * mix_2_1_simd
#define FFMAX(a, b)
Definition: common.h:94
#define NUM_NAMED_CHANNELS
Definition: rematrix.c:59
int32_t matrix32[SWR_CH_MAX][SWR_CH_MAX]
17.15 fixed point rematrixing coefficients
AudioData midbuf
intermediate audio data (postin/preout)
audio channel layout utility functions
#define AV_CH_LAYOUT_STEREO_DOWNMIX
#define FRONT_LEFT_OF_CENTER
Definition: rematrix.c:47
signed 32 bits, planar
Definition: samplefmt.h:68
int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride)
Set a customized remix matrix.
Definition: rematrix.c:61
mix_1_1_func_type * mix_1_1_f
mix_1_1_func_type * mix_1_1_simd
int64_t out_ch_layout
output channel layout
int bps
bytes per sample
#define AV_CH_FRONT_LEFT_OF_CENTER
uint8_t * native_matrix
mix_any_func_type * mix_any_f
#define AV_CH_FRONT_CENTER
#define FF_ARRAY_ELEMS(a)
#define AV_CH_FRONT_RIGHT_OF_CENTER
FILE * out
Definition: movenc-test.c:54
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
static av_cold int auto_matrix(SwrContext *s)
Definition: rematrix.c:113
#define AV_CH_FRONT_LEFT
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
void * buf
Definition: avisynth_c.h:553
static int clean_layout(SwrContext *s, int64_t layout)
Definition: rematrix.c:85
static int sane_layout(int64_t layout)
Definition: rematrix.c:96
#define BACK_LEFT
Definition: rematrix.c:45
void * av_calloc(size_t nmemb, size_t size)
Allocate a block of nmemb * size bytes with alignment suitable for all memory accesses (including vec...
Definition: mem.c:260
#define AV_CH_BACK_CENTER
uint8_t * native_one
#define AV_CH_SIDE_RIGHT
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:104
int64_t in_ch_layout
input channel layout
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
Get the packed alternative form of the given sample format.
Definition: samplefmt.c:73
uint8_t * native_simd_matrix
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
static double c[64]
float lfe_mix_level
LFE mixing level.
void( mix_any_func_type)(uint8_t **out, const uint8_t **in1, void *coeffp, integer len)
const char * av_get_channel_name(uint64_t channel)
Get the name of a given channel.
av_cold void swri_rematrix_free(SwrContext *s)
Definition: rematrix.c:437
int len
float rematrix_maxval
maximum value for rematrixing output
float rematrix_volume
rematrixing volume coefficient
float matrix[SWR_CH_MAX][SWR_CH_MAX]
floating point rematrixing coefficients
uint64_t layout
mix_2_1_func_type * mix_2_1_f
#define AV_CH_FRONT_RIGHT
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:67
static int even(int64_t layout)
Definition: rematrix.c:79
#define AV_CH_SIDE_LEFT
#define FRONT_LEFT
Definition: rematrix.c:41
uint8_t matrix_ch[SWR_CH_MAX][SWR_CH_MAX+1]
Lists of input channels per output channel that have non zero rematrixing coefficients.
uint8_t * ch[SWR_CH_MAX]
samples buffer per channel
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
int64_t user_out_ch_layout
User set output channel layout.
#define AV_CH_BACK_RIGHT