1/* 2 * audio conversion 3 * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/** 23 * @file libavcodec/audioconvert.c 24 * audio conversion 25 * @author Michael Niedermayer <michaelni@gmx.at> 26 */ 27 28#include "libavutil/avstring.h" 29#include "avcodec.h" 30#include "audioconvert.h" 31 32typedef struct SampleFmtInfo { 33 const char *name; 34 int bits; 35} SampleFmtInfo; 36 37/** this table gives more information about formats */ 38static const SampleFmtInfo sample_fmt_info[SAMPLE_FMT_NB] = { 39 [SAMPLE_FMT_U8] = { .name = "u8", .bits = 8 }, 40 [SAMPLE_FMT_S16] = { .name = "s16", .bits = 16 }, 41 [SAMPLE_FMT_S32] = { .name = "s32", .bits = 32 }, 42 [SAMPLE_FMT_FLT] = { .name = "flt", .bits = 32 }, 43 [SAMPLE_FMT_DBL] = { .name = "dbl", .bits = 64 }, 44}; 45 46const char *avcodec_get_sample_fmt_name(int sample_fmt) 47{ 48 if (sample_fmt < 0 || sample_fmt >= SAMPLE_FMT_NB) 49 return NULL; 50 return sample_fmt_info[sample_fmt].name; 51} 52 53enum SampleFormat avcodec_get_sample_fmt(const char* name) 54{ 55 int i; 56 57 for (i=0; i < SAMPLE_FMT_NB; i++) 58 if (!strcmp(sample_fmt_info[i].name, name)) 59 return i; 60 return SAMPLE_FMT_NONE; 61} 62 63void avcodec_sample_fmt_string (char *buf, int buf_size, int sample_fmt) 64{ 65 /* print header */ 66 if (sample_fmt < 0) 67 snprintf (buf, buf_size, "name " " depth"); 68 else if (sample_fmt < SAMPLE_FMT_NB) { 69 SampleFmtInfo info= sample_fmt_info[sample_fmt]; 70 snprintf (buf, buf_size, "%-6s" " %2d ", info.name, info.bits); 71 } 72} 73 74static const char* const channel_names[]={ 75 "FL", "FR", "FC", "LFE", "BL", "BR", "FLC", "FRC", 76 "BC", "SL", "SR", "TC", "TFL", "TFC", "TFR", "TBL", 77 "TBC", "TBR", 78 [29] = "DL", 79 [30] = "DR", 80}; 81 82const char *get_channel_name(int channel_id) 83{ 84 if (channel_id<0 || channel_id>=FF_ARRAY_ELEMS(channel_names)) 85 return NULL; 86 return channel_names[channel_id]; 87} 88 89int64_t avcodec_guess_channel_layout(int nb_channels, enum CodecID codec_id, const char *fmt_name) 90{ 91 switch(nb_channels) { 92 case 1: return CH_LAYOUT_MONO; 93 case 2: return CH_LAYOUT_STEREO; 94 case 3: return CH_LAYOUT_SURROUND; 95 case 4: return CH_LAYOUT_QUAD; 96 case 5: return CH_LAYOUT_5POINT0; 97 case 6: return CH_LAYOUT_5POINT1; 98 case 8: return CH_LAYOUT_7POINT1; 99 default: return 0; 100 } 101} 102 103static const struct { 104 const char *name; 105 int nb_channels; 106 int64_t layout; 107} channel_layout_map[] = { 108 { "mono", 1, CH_LAYOUT_MONO }, 109 { "stereo", 2, CH_LAYOUT_STEREO }, 110 { "surround", 3, CH_LAYOUT_SURROUND }, 111 { "quad", 4, CH_LAYOUT_QUAD }, 112 { "5.0", 5, CH_LAYOUT_5POINT0 }, 113 { "5.1", 6, CH_LAYOUT_5POINT1 }, 114 { "5.1+downmix", 8, CH_LAYOUT_5POINT1|CH_LAYOUT_STEREO_DOWNMIX, }, 115 { "7.1", 8, CH_LAYOUT_7POINT1 }, 116 { "7.1(wide)", 8, CH_LAYOUT_7POINT1_WIDE }, 117 { "7.1+downmix", 10, CH_LAYOUT_7POINT1|CH_LAYOUT_STEREO_DOWNMIX, }, 118 { 0 } 119}; 120 121void avcodec_get_channel_layout_string(char *buf, int buf_size, int nb_channels, int64_t channel_layout) 122{ 123 int i; 124 125 if (channel_layout==0) 126 channel_layout = avcodec_guess_channel_layout(nb_channels, CODEC_ID_NONE, NULL); 127 128 for (i=0; channel_layout_map[i].name; i++) 129 if (nb_channels == channel_layout_map[i].nb_channels && 130 channel_layout == channel_layout_map[i].layout) { 131 av_strlcpy(buf, channel_layout_map[i].name, buf_size); 132 return; 133 } 134 135 snprintf(buf, buf_size, "%d channels", nb_channels); 136 if (channel_layout) { 137 int i,ch; 138 av_strlcat(buf, " (", buf_size); 139 for(i=0,ch=0; i<64; i++) { 140 if ((channel_layout & (1L<<i))) { 141 const char *name = get_channel_name(i); 142 if (name) { 143 if (ch>0) av_strlcat(buf, "|", buf_size); 144 av_strlcat(buf, name, buf_size); 145 } 146 ch++; 147 } 148 } 149 av_strlcat(buf, ")", buf_size); 150 } 151} 152 153struct AVAudioConvert { 154 int in_channels, out_channels; 155 int fmt_pair; 156}; 157 158AVAudioConvert *av_audio_convert_alloc(enum SampleFormat out_fmt, int out_channels, 159 enum SampleFormat in_fmt, int in_channels, 160 const float *matrix, int flags) 161{ 162 AVAudioConvert *ctx; 163 if (in_channels!=out_channels) 164 return NULL; /* FIXME: not supported */ 165 ctx = av_malloc(sizeof(AVAudioConvert)); 166 if (!ctx) 167 return NULL; 168 ctx->in_channels = in_channels; 169 ctx->out_channels = out_channels; 170 ctx->fmt_pair = out_fmt + SAMPLE_FMT_NB*in_fmt; 171 return ctx; 172} 173 174void av_audio_convert_free(AVAudioConvert *ctx) 175{ 176 av_free(ctx); 177} 178 179int av_audio_convert(AVAudioConvert *ctx, 180 void * const out[6], const int out_stride[6], 181 const void * const in[6], const int in_stride[6], int len) 182{ 183 int ch; 184 185 //FIXME optimize common cases 186 187 for(ch=0; ch<ctx->out_channels; ch++){ 188 const int is= in_stride[ch]; 189 const int os= out_stride[ch]; 190 const uint8_t *pi= in[ch]; 191 uint8_t *po= out[ch]; 192 uint8_t *end= po + os*len; 193 if(!out[ch]) 194 continue; 195 196#define CONV(ofmt, otype, ifmt, expr)\ 197if(ctx->fmt_pair == ofmt + SAMPLE_FMT_NB*ifmt){\ 198 do{\ 199 *(otype*)po = expr; pi += is; po += os;\ 200 }while(po < end);\ 201} 202 203//FIXME put things below under ifdefs so we do not waste space for cases no codec will need 204//FIXME rounding and clipping ? 205 206 CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_U8 , *(const uint8_t*)pi) 207 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)<<8) 208 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)<<24) 209 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)*(1.0 / (1<<7))) 210 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)*(1.0 / (1<<7))) 211 else CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_S16, (*(const int16_t*)pi>>8) + 0x80) 212 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_S16, *(const int16_t*)pi) 213 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_S16, *(const int16_t*)pi<<16) 214 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_S16, *(const int16_t*)pi*(1.0 / (1<<15))) 215 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_S16, *(const int16_t*)pi*(1.0 / (1<<15))) 216 else CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_S32, (*(const int32_t*)pi>>24) + 0x80) 217 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_S32, *(const int32_t*)pi>>16) 218 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_S32, *(const int32_t*)pi) 219 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_S32, *(const int32_t*)pi*(1.0 / (1<<31))) 220 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_S32, *(const int32_t*)pi*(1.0 / (1<<31))) 221 else CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_FLT, lrintf(*(const float*)pi * (1<<7)) + 0x80) 222 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_FLT, lrintf(*(const float*)pi * (1<<15))) 223 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_FLT, lrintf(*(const float*)pi * (1<<31))) 224 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_FLT, *(const float*)pi) 225 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_FLT, *(const float*)pi) 226 else CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_DBL, lrint(*(const double*)pi * (1<<7)) + 0x80) 227 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_DBL, lrint(*(const double*)pi * (1<<15))) 228 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_DBL, lrint(*(const double*)pi * (1<<31))) 229 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_DBL, *(const double*)pi) 230 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_DBL, *(const double*)pi) 231 else return -1; 232 } 233 return 0; 234} 235