libaf/format.c

   1 /*
   2  * Copyright (C) 2005 Alex Beregszaszi
   3  *
   4  * This file is part of MPlayer.
   5  *
   6  * MPlayer is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * MPlayer 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
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <inttypes.h>
  25 #include <limits.h>
  26
  27 #include "af.h"
  28 #include "help_mp.h"
  29
  30 // Convert from string to format
  31 int af_str2fmt(const char* str)
  32 {
  33   int format=0;
  34   // Scan for endianness
  35   if(strstr(str,"be") || strstr(str,"BE"))
  36     format |= AF_FORMAT_BE;
  37   else if(strstr(str,"le") || strstr(str,"LE"))
  38     format |= AF_FORMAT_LE;
  39   else
  40     format |= AF_FORMAT_NE;
  41
  42   // Scan for special formats
  43   if(strstr(str,"mulaw") || strstr(str,"MULAW")){
  44     format |= AF_FORMAT_MU_LAW; return format;
  45   }
  46   if(strstr(str,"alaw") || strstr(str,"ALAW")){
  47     format |= AF_FORMAT_A_LAW; return format;
  48   }
  49   if(strstr(str,"ac3") || strstr(str,"AC3")){
  50     format |= AF_FORMAT_AC3; return format;
  51   }
  52   if(strstr(str,"mpeg2") || strstr(str,"MPEG2")){
  53     format |= AF_FORMAT_MPEG2; return format;
  54   }
  55   if(strstr(str,"imaadpcm") || strstr(str,"IMAADPCM")){
  56     format |= AF_FORMAT_IMA_ADPCM; return format;
  57   }
  58
  59   // Scan for int/float
  60   if(strstr(str,"float") || strstr(str,"FLOAT")){
  61     format |= AF_FORMAT_F; return format;
  62   }
  63   else
  64     format |= AF_FORMAT_I;
  65
  66   // Scan for signed/unsigned
  67   if(strstr(str,"unsigned") || strstr(str,"UNSIGNED"))
  68     format |= AF_FORMAT_US;
  69   else
  70     format |= AF_FORMAT_SI;
  71
  72   return format;
  73 }
  74
  75 int af_fmt2bits(int format)
  76 {
  77     return (format & AF_FORMAT_BITS_MASK)+8;
  78 //    return (((format & AF_FORMAT_BITS_MASK)>>3)+1) * 8;
  79 #if 0
  80     switch(format & AF_FORMAT_BITS_MASK)
  81     {
  82         case AF_FORMAT_8BIT: return 8;
  83         case AF_FORMAT_16BIT: return 16;
  84         case AF_FORMAT_24BIT: return 24;
  85         case AF_FORMAT_32BIT: return 32;
  86         case AF_FORMAT_48BIT: return 48;
  87     }
  88 #endif
  89     return -1;
  90 }
  91
  92 int af_bits2fmt(int bits)
  93 {
  94     return (bits/8 - 1) << 3;
  95 }
  96
  97 /* Convert format to str input str is a buffer for the
  98    converted string, size is the size of the buffer */
  99 char* af_fmt2str(int format, char* str, int size)
 100 {
 101   int i=0;
 102
 103   if (size < 1)
 104     return NULL;
 105   size--; // reserve one for terminating 0
 106
 107   // Endianness
 108   if(AF_FORMAT_LE == (format & AF_FORMAT_END_MASK))
 109     i+=snprintf(str,size-i,"little-endian ");
 110   else
 111     i+=snprintf(str,size-i,"big-endian ");
 112
 113   if(format & AF_FORMAT_SPECIAL_MASK){
 114     switch(format & AF_FORMAT_SPECIAL_MASK){
 115     case(AF_FORMAT_MU_LAW):
 116       i+=snprintf(&str[i],size-i,"mu-law "); break;
 117     case(AF_FORMAT_A_LAW):
 118       i+=snprintf(&str[i],size-i,"A-law "); break;
 119     case(AF_FORMAT_MPEG2):
 120       i+=snprintf(&str[i],size-i,"MPEG-2 "); break;
 121     case(AF_FORMAT_AC3):
 122       i+=snprintf(&str[i],size-i,"AC3 "); break;
 123     case(AF_FORMAT_IMA_ADPCM):
 124       i+=snprintf(&str[i],size-i,"IMA-ADPCM "); break;
 125     default:
 126       i+=snprintf(&str[i],size-i,MSGTR_AF_FORMAT_UnknownFormat);
 127     }
 128   }
 129   else{
 130     // Bits
 131     i+=snprintf(&str[i],size-i,"%d-bit ", af_fmt2bits(format));
 132
 133     // Point
 134     if(AF_FORMAT_F == (format & AF_FORMAT_POINT_MASK))
 135       i+=snprintf(&str[i],size-i,"float ");
 136     else{
 137       // Sign
 138       if(AF_FORMAT_US == (format & AF_FORMAT_SIGN_MASK))
 139         i+=snprintf(&str[i],size-i,"unsigned ");
 140       else
 141         i+=snprintf(&str[i],size-i,"signed ");
 142
 143       i+=snprintf(&str[i],size-i,"int ");
 144     }
 145   }
 146   // remove trailing space
 147   if (i > 0 && str[i - 1] == ' ')
 148     i--;
 149   str[i] = 0; // make sure it is 0 terminated.
 150   return str;
 151 }
 152
 153 static struct {
 154     const char *name;
 155     const int format;
 156 } af_fmtstr_table[] = {
 157     { "mulaw", AF_FORMAT_MU_LAW },
 158     { "alaw", AF_FORMAT_A_LAW },
 159     { "mpeg2", AF_FORMAT_MPEG2 },
 160     { "ac3", AF_FORMAT_AC3 },
 161     { "imaadpcm", AF_FORMAT_IMA_ADPCM },
 162
 163     { "u8", AF_FORMAT_U8 },
 164     { "s8", AF_FORMAT_S8 },
 165     { "u16le", AF_FORMAT_U16_LE },
 166     { "u16be", AF_FORMAT_U16_BE },
 167     { "u16ne", AF_FORMAT_U16_NE },
 168     { "s16le", AF_FORMAT_S16_LE },
 169     { "s16be", AF_FORMAT_S16_BE },
 170     { "s16ne", AF_FORMAT_S16_NE },
 171     { "u24le", AF_FORMAT_U24_LE },
 172     { "u24be", AF_FORMAT_U24_BE },
 173     { "u24ne", AF_FORMAT_U24_NE },
 174     { "s24le", AF_FORMAT_S24_LE },
 175     { "s24be", AF_FORMAT_S24_BE },
 176     { "s24ne", AF_FORMAT_S24_NE },
 177     { "u32le", AF_FORMAT_U32_LE },
 178     { "u32be", AF_FORMAT_U32_BE },
 179     { "u32ne", AF_FORMAT_U32_NE },
 180     { "s32le", AF_FORMAT_S32_LE },
 181     { "s32be", AF_FORMAT_S32_BE },
 182     { "s32ne", AF_FORMAT_S32_NE },
 183     { "floatle", AF_FORMAT_FLOAT_LE },
 184     { "floatbe", AF_FORMAT_FLOAT_BE },
 185     { "floatne", AF_FORMAT_FLOAT_NE },
 186
 187     { NULL, 0 }
 188 };
 189
 190 const char *af_fmt2str_short(int format)
 191 {
 192     int i;
 193
 194     for (i = 0; af_fmtstr_table[i].name; i++)
 195         if (af_fmtstr_table[i].format == format)
 196             return af_fmtstr_table[i].name;
 197
 198     return "??";
 199 }
 200
 201 int af_str2fmt_short(const char* str)
 202 {
 203     int i;
 204
 205     for (i = 0; af_fmtstr_table[i].name; i++)
 206         if (!strcasecmp(str, af_fmtstr_table[i].name))
 207             return af_fmtstr_table[i].format;
 208
 209     return -1;
 210 }