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 24 * audio conversion 25 * @author Michael Niedermayer <michaelni@gmx.at> 26 */ 27 28#include "libavutil/avstring.h" 29#include "libavutil/libm.h" 30#include "avcodec.h" 31#include "audioconvert.h" 32 33typedef struct SampleFmtInfo { 34 const char *name; 35 int bits; 36} SampleFmtInfo; 37 38/** this table gives more information about formats */ 39static const SampleFmtInfo sample_fmt_info[SAMPLE_FMT_NB] = { 40 [SAMPLE_FMT_U8] = { .name = "u8", .bits = 8 }, 41 [SAMPLE_FMT_S16] = { .name = "s16", .bits = 16 }, 42 [SAMPLE_FMT_S32] = { .name = "s32", .bits = 32 }, 43 [SAMPLE_FMT_FLT] = { .name = "flt", .bits = 32 }, 44 [SAMPLE_FMT_DBL] = { .name = "dbl", .bits = 64 }, 45}; 46 47const char *avcodec_get_sample_fmt_name(int sample_fmt) 48{ 49 if (sample_fmt < 0 || sample_fmt >= SAMPLE_FMT_NB) 50 return NULL; 51 return sample_fmt_info[sample_fmt].name; 52} 53 54enum SampleFormat avcodec_get_sample_fmt(const char* name) 55{ 56 int i; 57 58 for (i=0; i < SAMPLE_FMT_NB; i++) 59 if (!strcmp(sample_fmt_info[i].name, name)) 60 return i; 61 return SAMPLE_FMT_NONE; 62} 63 64void avcodec_sample_fmt_string (char *buf, int buf_size, int sample_fmt) 65{ 66 /* print header */ 67 if (sample_fmt < 0) 68 snprintf (buf, buf_size, "name " " depth"); 69 else if (sample_fmt < SAMPLE_FMT_NB) { 70 SampleFmtInfo info= sample_fmt_info[sample_fmt]; 71 snprintf (buf, buf_size, "%-6s" " %2d ", info.name, info.bits); 72 } 73} 74 75static const char* const channel_names[]={ 76 "FL", "FR", "FC", "LFE", "BL", "BR", "FLC", "FRC", 77 "BC", "SL", "SR", "TC", "TFL", "TFC", "TFR", "TBL", 78 "TBC", "TBR", 79 [29] = "DL", 80 [30] = "DR", 81}; 82 83static const char *get_channel_name(int channel_id) 84{ 85 if (channel_id<0 || channel_id>=FF_ARRAY_ELEMS(channel_names)) 86 return NULL; 87 return channel_names[channel_id]; 88} 89 90int64_t avcodec_guess_channel_layout(int nb_channels, enum CodecID codec_id, const char *fmt_name) 91{ 92 switch(nb_channels) { 93 case 1: return CH_LAYOUT_MONO; 94 case 2: return CH_LAYOUT_STEREO; 95 case 3: return CH_LAYOUT_SURROUND; 96 case 4: return CH_LAYOUT_QUAD; 97 case 5: return CH_LAYOUT_5POINT0; 98 case 6: return CH_LAYOUT_5POINT1; 99 case 8: return CH_LAYOUT_7POINT1; 100 default: return 0; 101 } 102} 103 104static const struct { 105 const char *name; 106 int nb_channels; 107 int64_t layout; 108} channel_layout_map[] = { 109 { "mono", 1, CH_LAYOUT_MONO }, 110 { "stereo", 2, CH_LAYOUT_STEREO }, 111 { "4.0", 4, CH_LAYOUT_4POINT0 }, 112 { "quad", 4, CH_LAYOUT_QUAD }, 113 { "5.0", 5, CH_LAYOUT_5POINT0 }, 114 { "5.0", 5, CH_LAYOUT_5POINT0_BACK }, 115 { "5.1", 6, CH_LAYOUT_5POINT1 }, 116 { "5.1", 6, CH_LAYOUT_5POINT1_BACK }, 117 { "5.1+downmix", 8, CH_LAYOUT_5POINT1|CH_LAYOUT_STEREO_DOWNMIX, }, 118 { "7.1", 8, CH_LAYOUT_7POINT1 }, 119 { "7.1(wide)", 8, CH_LAYOUT_7POINT1_WIDE }, 120 { "7.1+downmix", 10, CH_LAYOUT_7POINT1|CH_LAYOUT_STEREO_DOWNMIX, }, 121 { 0 } 122}; 123 124void avcodec_get_channel_layout_string(char *buf, int buf_size, int nb_channels, int64_t channel_layout) 125{ 126 int i; 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 153int avcodec_channel_layout_num_channels(int64_t channel_layout) 154{ 155 int count; 156 uint64_t x = channel_layout; 157 for (count = 0; x; count++) 158 x &= x-1; // unset lowest set bit 159 return count; 160} 161 162struct AVAudioConvert { 163 int in_channels, out_channels; 164 int fmt_pair; 165}; 166 167AVAudioConvert *av_audio_convert_alloc(enum SampleFormat out_fmt, int out_channels, 168 enum SampleFormat in_fmt, int in_channels, 169 const float *matrix, int flags) 170{ 171 AVAudioConvert *ctx; 172 if (in_channels!=out_channels) 173 return NULL; /* FIXME: not supported */ 174 ctx = av_malloc(sizeof(AVAudioConvert)); 175 if (!ctx) 176 return NULL; 177 ctx->in_channels = in_channels; 178 ctx->out_channels = out_channels; 179 ctx->fmt_pair = out_fmt + SAMPLE_FMT_NB*in_fmt; 180 return ctx; 181} 182 183void av_audio_convert_free(AVAudioConvert *ctx) 184{ 185 av_free(ctx); 186} 187 188int av_audio_convert(AVAudioConvert *ctx, 189 void * const out[6], const int out_stride[6], 190 const void * const in[6], const int in_stride[6], int len) 191{ 192 int ch; 193 194 //FIXME optimize common cases 195 196 for(ch=0; ch<ctx->out_channels; ch++){ 197 const int is= in_stride[ch]; 198 const int os= out_stride[ch]; 199 const uint8_t *pi= in[ch]; 200 uint8_t *po= out[ch]; 201 uint8_t *end= po + os*len; 202 if(!out[ch]) 203 continue; 204 205#define CONV(ofmt, otype, ifmt, expr)\ 206if(ctx->fmt_pair == ofmt + SAMPLE_FMT_NB*ifmt){\ 207 do{\ 208 *(otype*)po = expr; pi += is; po += os;\ 209 }while(po < end);\ 210} 211 212//FIXME put things below under ifdefs so we do not waste space for cases no codec will need 213//FIXME rounding ? 214 215 CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_U8 , *(const uint8_t*)pi) 216 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)<<8) 217 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)<<24) 218 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)*(1.0 / (1<<7))) 219 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_U8 , (*(const uint8_t*)pi - 0x80)*(1.0 / (1<<7))) 220 else CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_S16, (*(const int16_t*)pi>>8) + 0x80) 221 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_S16, *(const int16_t*)pi) 222 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_S16, *(const int16_t*)pi<<16) 223 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_S16, *(const int16_t*)pi*(1.0 / (1<<15))) 224 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_S16, *(const int16_t*)pi*(1.0 / (1<<15))) 225 else CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_S32, (*(const int32_t*)pi>>24) + 0x80) 226 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_S32, *(const int32_t*)pi>>16) 227 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_S32, *(const int32_t*)pi) 228 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_S32, *(const int32_t*)pi*(1.0 / (1<<31))) 229 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_S32, *(const int32_t*)pi*(1.0 / (1<<31))) 230 else CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_FLT, av_clip_uint8( lrintf(*(const float*)pi * (1<<7)) + 0x80)) 231 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_FLT, av_clip_int16( lrintf(*(const float*)pi * (1<<15)))) 232 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float*)pi * (1U<<31)))) 233 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_FLT, *(const float*)pi) 234 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_FLT, *(const float*)pi) 235 else CONV(SAMPLE_FMT_U8 , uint8_t, SAMPLE_FMT_DBL, av_clip_uint8( lrint(*(const double*)pi * (1<<7)) + 0x80)) 236 else CONV(SAMPLE_FMT_S16, int16_t, SAMPLE_FMT_DBL, av_clip_int16( lrint(*(const double*)pi * (1<<15)))) 237 else CONV(SAMPLE_FMT_S32, int32_t, SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double*)pi * (1U<<31)))) 238 else CONV(SAMPLE_FMT_FLT, float , SAMPLE_FMT_DBL, *(const double*)pi) 239 else CONV(SAMPLE_FMT_DBL, double , SAMPLE_FMT_DBL, *(const double*)pi) 240 else return -1; 241 } 242 return 0; 243} 244