src/pcm/pcm_alaw.c

   1 /*
   2  *  PCM - A-Law conversion
   3  *  Copyright (c) 2000 by Abramo Bagnara <abramo@alsa-project.org>
   4  *
   5  *
   6  *   This library is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU Library General Public License as
   8  *   published by the Free Software Foundation; either version 2 of
   9  *   the License, or (at your option) any later version.
  10  *
  11  *   This program 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 Library General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU Library General Public
  17  *   License along with this library; if not, write to the Free Software
  18  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  */
  21
  22 #include <byteswap.h>
  23 #include "pcm_local.h"
  24 #include "pcm_plugin.h"
  25
  26 typedef void (*alaw_f)(const snd_pcm_channel_area_t *dst_areas,
  27                        snd_pcm_uframes_t dst_offset,
  28                        const snd_pcm_channel_area_t *src_areas,
  29                        snd_pcm_uframes_t src_offset,
  30                        unsigned int channels, snd_pcm_uframes_t frames, int getputidx);
  31
  32 typedef struct {
  33         /* This field need to be the first */
  34         snd_pcm_plugin_t plug;
  35         int getput_idx;
  36         alaw_f func;
  37         snd_pcm_format_t sformat;
  38 } snd_pcm_alaw_t;
  39
  40 static inline int val_seg(int val)
  41 {
  42         int r = 1;
  43         val >>= 8;
  44         if (val & 0xf0) {
  45                 val >>= 4;
  46                 r += 4;
  47         }
  48         if (val & 0x0c) {
  49                 val >>= 2;
  50                 r += 2;
  51         }
  52         if (val & 0x02)
  53                 r += 1;
  54         return r;
  55 }
  56
  57 /*
  58  * s16_to_alaw() - Convert a 16-bit linear PCM value to 8-bit A-law
  59  *
  60  * s16_to_alaw() accepts an 16-bit integer and encodes it as A-law data.
  61  *
  62  *              Linear Input Code       Compressed Code
  63  *      ------------------------        ---------------
  64  *      0000000wxyza                    000wxyz
  65  *      0000001wxyza                    001wxyz
  66  *      000001wxyzab                    010wxyz
  67  *      00001wxyzabc                    011wxyz
  68  *      0001wxyzabcd                    100wxyz
  69  *      001wxyzabcde                    101wxyz
  70  *      01wxyzabcdef                    110wxyz
  71  *      1wxyzabcdefg                    111wxyz
  72  *
  73  * For further information see John C. Bellamy's Digital Telephony, 1982,
  74  * John Wiley & Sons, pps 98-111 and 472-476.
  75  */
  76
  77 static unsigned char s16_to_alaw(int pcm_val)
  78 {
  79         int             mask;
  80         int             seg;
  81         unsigned char   aval;
  82
  83         if (pcm_val >= 0) {
  84                 mask = 0xD5;
  85         } else {
  86                 mask = 0x55;
  87                 pcm_val = -pcm_val;
  88                 if (pcm_val > 0x7fff)
  89                         pcm_val = 0x7fff;
  90         }
  91
  92         if (pcm_val < 256)
  93                 aval = pcm_val >> 4;
  94         else {
  95                 /* Convert the scaled magnitude to segment number. */
  96                 seg = val_seg(pcm_val);
  97                 aval = (seg << 4) | ((pcm_val >> (seg + 3)) & 0x0f);
  98         }
  99         return aval ^ mask;
 100 }
 101
 102 /*
 103  * alaw_to_s16() - Convert an A-law value to 16-bit linear PCM
 104  *
 105  */
 106 static int alaw_to_s16(unsigned char a_val)
 107 {
 108         int             t;
 109         int             seg;
 110
 111         a_val ^= 0x55;
 112         t = a_val & 0x7f;
 113         if (t < 16)
 114                 t = (t << 4) + 8;
 115         else {
 116                 seg = (t >> 4) & 0x07;
 117                 t = ((t & 0x0f) << 4) + 0x108;
 118                 t <<= seg -1;
 119         }
 120         return ((a_val & 0x80) ? t : -t);
 121 }
 122
 123 void snd_pcm_alaw_decode(const snd_pcm_channel_area_t *dst_areas,
 124                          snd_pcm_uframes_t dst_offset,
 125                          const snd_pcm_channel_area_t *src_areas,
 126                          snd_pcm_uframes_t src_offset,
 127                          unsigned int channels, snd_pcm_uframes_t frames, int putidx)
 128 {
 129 #define PUT16_LABELS
 130 #include "plugin_ops.h"
 131 #undef PUT16_LABELS
 132         void *put = put16_labels[putidx];
 133         unsigned int channel;
 134         for (channel = 0; channel < channels; ++channel) {
 135                 char *src;
 136                 char *dst;
 137                 int src_step, dst_step;
 138                 snd_pcm_uframes_t frames1;
 139                 const snd_pcm_channel_area_t *src_area = &src_areas[channel];
 140                 const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 141 #if 0
 142                 if (!src_area->enabled) {
 143                         if (dst_area->wanted)
 144                                 snd_pcm_area_silence(&dst_areas[channel], dst_offset, frames, dst_sfmt);
 145                         dst_area->enabled = 0;
 146                         continue;
 147                 }
 148                 dst_area->enabled = 1;
 149 #endif
 150                 src = snd_pcm_channel_area_addr(src_area, src_offset);
 151                 dst = snd_pcm_channel_area_addr(dst_area, dst_offset);
 152                 src_step = snd_pcm_channel_area_step(src_area);
 153                 dst_step = snd_pcm_channel_area_step(dst_area);
 154                 frames1 = frames;
 155                 while (frames1-- > 0) {
 156                         int16_t sample = alaw_to_s16(*src);
 157                         goto *put;
 158 #define PUT16_END after
 159 #include "plugin_ops.h"
 160 #undef PUT16_END
 161                 after:
 162                         src += src_step;
 163                         dst += dst_step;
 164                 }
 165         }
 166 }
 167
 168 void snd_pcm_alaw_encode(const snd_pcm_channel_area_t *dst_areas,
 169                          snd_pcm_uframes_t dst_offset,
 170                          const snd_pcm_channel_area_t *src_areas,
 171                          snd_pcm_uframes_t src_offset,
 172                          unsigned int channels, snd_pcm_uframes_t frames, int getidx)
 173 {
 174 #define GET16_LABELS
 175 #include "plugin_ops.h"
 176 #undef GET16_LABELS
 177         void *get = get16_labels[getidx];
 178         unsigned int channel;
 179         int16_t sample = 0;
 180         for (channel = 0; channel < channels; ++channel) {
 181                 char *src;
 182                 char *dst;
 183                 int src_step, dst_step;
 184                 snd_pcm_uframes_t frames1;
 185                 const snd_pcm_channel_area_t *src_area = &src_areas[channel];
 186                 const snd_pcm_channel_area_t *dst_area = &dst_areas[channel];
 187 #if 0
 188                 if (!src_area->enabled) {
 189                         if (dst_area->wanted)
 190                                 snd_pcm_area_silence(&dst_area->area, 0, frames, dst_sfmt);
 191                         dst_area->enabled = 0;
 192                         continue;
 193                 }
 194                 dst_area->enabled = 1;
 195 #endif
 196                 src = snd_pcm_channel_area_addr(src_area, src_offset);
 197                 dst = snd_pcm_channel_area_addr(dst_area, dst_offset);
 198                 src_step = snd_pcm_channel_area_step(src_area);
 199                 dst_step = snd_pcm_channel_area_step(dst_area);
 200                 frames1 = frames;
 201                 while (frames1-- > 0) {
 202                         goto *get;
 203 #define GET16_END after
 204 #include "plugin_ops.h"
 205 #undef GET16_END
 206                 after:
 207                         *dst = s16_to_alaw(sample);
 208                         src += src_step;
 209                         dst += dst_step;
 210                 }
 211         }
 212 }
 213
 214 static int snd_pcm_alaw_hw_refine_cprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 215 {
 216         snd_pcm_alaw_t *alaw = pcm->private;
 217         int err;
 218         snd_pcm_access_mask_t *access_mask = alloca(snd_pcm_access_mask_sizeof());
 219         snd_mask_load(access_mask, SND_PCM_ACCBIT_PLUGIN);
 220         err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_ACCESS,
 221                                      access_mask);
 222         if (err < 0)
 223                 return err;
 224         if (alaw->sformat == SND_PCM_FORMAT_A_LAW) {
 225                 snd_pcm_format_mask_t *format_mask = alloca(snd_pcm_format_mask_sizeof());
 226                 snd_mask_load(format_mask, SND_PCM_FMTBIT_LINEAR);
 227                 err = _snd_pcm_hw_param_set_mask(params, SND_PCM_HW_PARAM_FORMAT,
 228                                                  format_mask);
 229         } else {
 230                 err = _snd_pcm_hw_params_set_format(params,
 231                                                    SND_PCM_FORMAT_A_LAW);
 232         }
 233         if (err < 0)
 234                 return err;
 235         err = _snd_pcm_hw_params_set_subformat(params, SND_PCM_SUBFORMAT_STD);
 236         if (err < 0)
 237                 return err;
 238         params->info &= ~(SND_PCM_INFO_MMAP | SND_PCM_INFO_MMAP_VALID);
 239         return 0;
 240 }
 241
 242 static int snd_pcm_alaw_hw_refine_sprepare(snd_pcm_t *pcm, snd_pcm_hw_params_t *sparams)
 243 {
 244         snd_pcm_alaw_t *alaw = pcm->private;
 245         snd_pcm_access_mask_t *saccess_mask = alloca(snd_pcm_access_mask_sizeof());
 246         snd_mask_load(saccess_mask, SND_PCM_ACCBIT_MMAP);
 247         _snd_pcm_hw_params_any(sparams);
 248         _snd_pcm_hw_param_set_mask(sparams, SND_PCM_HW_PARAM_ACCESS,
 249                                 saccess_mask);
 250         _snd_pcm_hw_params_set_format(sparams, alaw->sformat);
 251         _snd_pcm_hw_params_set_subformat(sparams, SND_PCM_SUBFORMAT_STD);
 252         return 0;
 253 }
 254
 255 static int snd_pcm_alaw_hw_refine_schange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params,
 256                                             snd_pcm_hw_params_t *sparams)
 257 {
 258         int err;
 259         unsigned int links = (SND_PCM_HW_PARBIT_CHANNELS |
 260                               SND_PCM_HW_PARBIT_RATE |
 261                               SND_PCM_HW_PARBIT_PERIOD_SIZE |
 262                               SND_PCM_HW_PARBIT_BUFFER_SIZE |
 263                               SND_PCM_HW_PARBIT_PERIODS |
 264                               SND_PCM_HW_PARBIT_PERIOD_TIME |
 265                               SND_PCM_HW_PARBIT_BUFFER_TIME |
 266                               SND_PCM_HW_PARBIT_TICK_TIME);
 267         err = _snd_pcm_hw_params_refine(sparams, links, params);
 268         if (err < 0)
 269                 return err;
 270         return 0;
 271 }
 272
 273 static int snd_pcm_alaw_hw_refine_cchange(snd_pcm_t *pcm ATTRIBUTE_UNUSED, snd_pcm_hw_params_t *params,
 274                                             snd_pcm_hw_params_t *sparams)
 275 {
 276         int err;
 277         unsigned int links = (SND_PCM_HW_PARBIT_CHANNELS |
 278                               SND_PCM_HW_PARBIT_RATE |
 279                               SND_PCM_HW_PARBIT_PERIOD_SIZE |
 280                               SND_PCM_HW_PARBIT_BUFFER_SIZE |
 281                               SND_PCM_HW_PARBIT_PERIODS |
 282                               SND_PCM_HW_PARBIT_PERIOD_TIME |
 283                               SND_PCM_HW_PARBIT_BUFFER_TIME |
 284                               SND_PCM_HW_PARBIT_TICK_TIME);
 285         err = _snd_pcm_hw_params_refine(params, links, sparams);
 286         if (err < 0)
 287                 return err;
 288         return 0;
 289 }
 290
 291 static int snd_pcm_alaw_hw_refine(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 292 {
 293         return snd_pcm_hw_refine_slave(pcm, params,
 294                                        snd_pcm_alaw_hw_refine_cprepare,
 295                                        snd_pcm_alaw_hw_refine_cchange,
 296                                        snd_pcm_alaw_hw_refine_sprepare,
 297                                        snd_pcm_alaw_hw_refine_schange,
 298                                        snd_pcm_plugin_hw_refine_slave);
 299 }
 300
 301 static int snd_pcm_alaw_hw_params(snd_pcm_t *pcm, snd_pcm_hw_params_t * params)
 302 {
 303         snd_pcm_alaw_t *alaw = pcm->private;
 304         int err = snd_pcm_hw_params_slave(pcm, params,
 305                                           snd_pcm_alaw_hw_refine_cchange,
 306                                           snd_pcm_alaw_hw_refine_sprepare,
 307                                           snd_pcm_alaw_hw_refine_schange,
 308                                           snd_pcm_plugin_hw_params_slave);
 309         if (err < 0)
 310                 return err;
 311
 312         if (pcm->stream == SND_PCM_STREAM_PLAYBACK) {
 313                 if (alaw->sformat == SND_PCM_FORMAT_A_LAW) {
 314                         alaw->getput_idx = snd_pcm_linear_get_index(snd_pcm_hw_params_get_format(params), SND_PCM_FORMAT_S16);
 315                         alaw->func = snd_pcm_alaw_encode;
 316                 } else {
 317                         alaw->getput_idx = snd_pcm_linear_put_index(SND_PCM_FORMAT_S16, alaw->sformat);
 318                         alaw->func = snd_pcm_alaw_decode;
 319                 }
 320         } else {
 321                 if (alaw->sformat == SND_PCM_FORMAT_A_LAW) {
 322                         alaw->getput_idx = snd_pcm_linear_put_index(SND_PCM_FORMAT_S16, snd_pcm_hw_params_get_format(params));
 323                         alaw->func = snd_pcm_alaw_decode;
 324                 } else {
 325                         alaw->getput_idx = snd_pcm_linear_get_index(alaw->sformat, SND_PCM_FORMAT_S16);
 326                         alaw->func = snd_pcm_alaw_encode;
 327                 }
 328         }
 329         return 0;
 330 }
 331
 332 static snd_pcm_sframes_t snd_pcm_alaw_write_areas(snd_pcm_t *pcm,
 333                                         const snd_pcm_channel_area_t *areas,
 334                                         snd_pcm_uframes_t offset,
 335                                         snd_pcm_uframes_t size,
 336                                         snd_pcm_uframes_t *slave_sizep)
 337 {
 338         snd_pcm_alaw_t *alaw = pcm->private;
 339         snd_pcm_t *slave = alaw->plug.slave;
 340         snd_pcm_uframes_t xfer = 0;
 341         snd_pcm_sframes_t err = 0;
 342         if (slave_sizep && *slave_sizep < size)
 343                 size = *slave_sizep;
 344         assert(size > 0);
 345         while (xfer < size) {
 346                 snd_pcm_uframes_t frames = snd_pcm_mmap_playback_xfer(slave, size - xfer);
 347                 alaw->func(snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
 348                            areas, offset,
 349                            pcm->channels, frames,
 350                            alaw->getput_idx);
 351                 err = snd_pcm_mmap_forward(slave, frames);
 352                 if (err < 0)
 353                         break;
 354                 assert((snd_pcm_uframes_t)err == frames);
 355                 offset += err;
 356                 xfer += err;
 357                 snd_pcm_mmap_hw_forward(pcm, err);
 358         }
 359         if (xfer > 0) {
 360                 if (slave_sizep)
 361                         *slave_sizep = xfer;
 362                 return xfer;
 363         }
 364         return err;
 365 }
 366
 367 static snd_pcm_sframes_t snd_pcm_alaw_read_areas(snd_pcm_t *pcm,
 368                                        const snd_pcm_channel_area_t *areas,
 369                                        snd_pcm_uframes_t offset,
 370                                        snd_pcm_uframes_t size,
 371                                        snd_pcm_uframes_t *slave_sizep)
 372 {
 373         snd_pcm_alaw_t *alaw = pcm->private;
 374         snd_pcm_t *slave = alaw->plug.slave;
 375         snd_pcm_uframes_t xfer = 0;
 376         snd_pcm_sframes_t err = 0;
 377         if (slave_sizep && *slave_sizep < size)
 378                 size = *slave_sizep;
 379         assert(size > 0);
 380         while (xfer < size) {
 381                 snd_pcm_uframes_t frames = snd_pcm_mmap_capture_xfer(slave, size - xfer);
 382                 alaw->func(areas, offset,
 383                            snd_pcm_mmap_areas(slave), snd_pcm_mmap_offset(slave),
 384                            pcm->channels, frames,
 385                            alaw->getput_idx);
 386                 err = snd_pcm_mmap_forward(slave, frames);
 387                 if (err < 0)
 388                         break;
 389                 assert((snd_pcm_uframes_t)err == frames);
 390                 offset += err;
 391                 xfer += err;
 392                 snd_pcm_mmap_hw_forward(pcm, err);
 393         }
 394         if (xfer > 0) {
 395                 if (slave_sizep)
 396                         *slave_sizep = xfer;
 397                 return xfer;
 398         }
 399         return err;
 400 }
 401
 402 static void snd_pcm_alaw_dump(snd_pcm_t *pcm, snd_output_t *out)
 403 {
 404         snd_pcm_alaw_t *alaw = pcm->private;
 405         snd_output_printf(out, "A-Law conversion PCM (%s)\n",
 406                 snd_pcm_format_name(alaw->sformat));
 407         if (pcm->setup) {
 408                 snd_output_printf(out, "Its setup is:\n");
 409                 snd_pcm_dump_setup(pcm, out);
 410         }
 411         snd_output_printf(out, "Slave: ");
 412         snd_pcm_dump(alaw->plug.slave, out);
 413 }
 414
 415 snd_pcm_ops_t snd_pcm_alaw_ops = {
 416         close: snd_pcm_plugin_close,
 417         info: snd_pcm_plugin_info,
 418         hw_refine: snd_pcm_alaw_hw_refine,
 419         hw_params: snd_pcm_alaw_hw_params,
 420         hw_free: snd_pcm_plugin_hw_free,
 421         sw_params: snd_pcm_plugin_sw_params,
 422         channel_info: snd_pcm_plugin_channel_info,
 423         dump: snd_pcm_alaw_dump,
 424         nonblock: snd_pcm_plugin_nonblock,
 425         async: snd_pcm_plugin_async,
 426         mmap: snd_pcm_plugin_mmap,
 427         munmap: snd_pcm_plugin_munmap,
 428 };
 429
 430 int snd_pcm_alaw_open(snd_pcm_t **pcmp, char *name, snd_pcm_format_t sformat, snd_pcm_t *slave, int close_slave)
 431 {
 432         snd_pcm_t *pcm;
 433         snd_pcm_alaw_t *alaw;
 434         assert(pcmp && slave);
 435         if (snd_pcm_format_linear(sformat) != 1 &&
 436             sformat != SND_PCM_FORMAT_A_LAW)
 437                 return -EINVAL;
 438         alaw = calloc(1, sizeof(snd_pcm_alaw_t));
 439         if (!alaw) {
 440                 return -ENOMEM;
 441         }
 442         alaw->sformat = sformat;
 443         alaw->plug.read = snd_pcm_alaw_read_areas;
 444         alaw->plug.write = snd_pcm_alaw_write_areas;
 445         alaw->plug.slave = slave;
 446         alaw->plug.close_slave = close_slave;
 447
 448         pcm = calloc(1, sizeof(snd_pcm_t));
 449         if (!pcm) {
 450                 free(alaw);
 451                 return -ENOMEM;
 452         }
 453         if (name)
 454                 pcm->name = strdup(name);
 455         pcm->type = SND_PCM_TYPE_ALAW;
 456         pcm->stream = slave->stream;
 457         pcm->mode = slave->mode;
 458         pcm->ops = &snd_pcm_alaw_ops;
 459         pcm->op_arg = pcm;
 460         pcm->fast_ops = &snd_pcm_plugin_fast_ops;
 461         pcm->fast_op_arg = pcm;
 462         pcm->private = alaw;
 463         pcm->poll_fd = slave->poll_fd;
 464         pcm->hw_ptr = &alaw->plug.hw_ptr;
 465         pcm->appl_ptr = &alaw->plug.appl_ptr;
 466         *pcmp = pcm;
 467
 468         return 0;
 469 }
 470
 471 int _snd_pcm_alaw_open(snd_pcm_t **pcmp, char *name,
 472                          snd_config_t *conf,
 473                          snd_pcm_stream_t stream, int mode)
 474 {
 475         snd_config_iterator_t i;
 476         char *sname = NULL;
 477         int err;
 478         snd_pcm_t *spcm;
 479         snd_pcm_format_t sformat = SND_PCM_FORMAT_NONE;
 480         snd_config_foreach(i, conf) {
 481                 snd_config_t *n = snd_config_entry(i);
 482                 if (strcmp(n->id, "comment") == 0)
 483                         continue;
 484                 if (strcmp(n->id, "type") == 0)
 485                         continue;
 486                 if (strcmp(n->id, "stream") == 0)
 487                         continue;
 488                 if (strcmp(n->id, "sname") == 0) {
 489                         err = snd_config_string_get(n, &sname);
 490                         if (err < 0) {
 491                                 ERR("Invalid type for %s", n->id);
 492                                 return -EINVAL;
 493                         }
 494                         continue;
 495                 }
 496                 if (strcmp(n->id, "sformat") == 0) {
 497                         char *f;
 498                         err = snd_config_string_get(n, &f);
 499                         if (err < 0) {
 500                                 ERR("Invalid type for %s", n->id);
 501                                 return -EINVAL;
 502                         }
 503                         sformat = snd_pcm_format_value(f);
 504                         if (sformat == SND_PCM_FORMAT_NONE) {
 505                                 ERR("Unknown sformat");
 506                                 return -EINVAL;
 507                         }
 508                         if (snd_pcm_format_linear(sformat) != 1 &&
 509                             sformat != SND_PCM_FORMAT_A_LAW) {
 510                                 ERR("Invalid sformat");
 511                                 return -EINVAL;
 512                         }
 513                         continue;
 514                 }
 515                 ERR("Unknown field %s", n->id);
 516                 return -EINVAL;
 517         }
 518         if (!sname) {
 519                 ERR("sname is not defined");
 520                 return -EINVAL;
 521         }
 522         if (sformat == SND_PCM_FORMAT_NONE) {
 523                 ERR("sformat is not defined");
 524                 return -EINVAL;
 525         }
 526         /* This is needed cause snd_config_update may destroy config */
 527         sname = strdup(sname);
 528         if (!sname)
 529                 return  -ENOMEM;
 530         err = snd_pcm_open(&spcm, sname, stream, mode);
 531         free(sname);
 532         if (err < 0)
 533                 return err;
 534         err = snd_pcm_alaw_open(pcmp, name, sformat, spcm, 1);
 535         if (err < 0)
 536                 snd_pcm_close(spcm);
 537         return err;
 538 }
 539
 540