1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0/ 9 * Copyright (C) 2012 The Android Open Source Project 10 * 11 * Licensed under the Apache License, Version 2.0 (the "License"); 12 * you may not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, 19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 */ 23 24 /* 25 * This code has modified by Intel Corporation 26 */ 27 28 /* 29 * Copyright (c) 2014, Intel Corporation 30 * 31 * Licensed under the Apache License, Version 2.0 (the "License"); 32 * you may not use this file except in compliance with the License. 33 * You may obtain a copy of the License at 34 * 35 * http://www.apache.org/licenses/LICENSE-2.0 36 * 37 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 38 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 39 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 40 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 41 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 42 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 43 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 44 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 45 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 46 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 47 */ 48 49 #define LOG_TAG "tiny_hdmi_audio_hw" 50 //#define LOG_NDEBUG 0 51 52 #include <errno.h> 53 #include <pthread.h> 54 #include <stdint.h> 55 #include <sys/time.h> 56 #include <stdlib.h> 57 58 #include <cutils/log.h> 59 #include <cutils/str_parms.h> 60 #include <cutils/properties.h> 61 62 #include <hardware/hardware.h> 63 #include <system/audio.h> 64 #include <hardware/audio.h> 65 66 #include <sound/asound.h> 67 #include <tinyalsa/asoundlib.h> 68 69 #define UNUSED_PARAMETER(x) (void)(x) 70 71 #define DEFAULT_CARD 0 72 #define DEFAULT_DEVICE 0 73 74 /*this is used to avoid starvation*/ 75 #define LATENCY_TO_BUFFER_SIZE_RATIO 2 76 77 /*Playback Channel Map*/ 78 #define CHANNEL_MAP_REQUEST 2 79 80 /*global - keep track of the active device. 81 This is needed since we are supporting more 82 than one profile for HDMI. The Flinger 83 assumes we can suport multiple streams 84 at the same time. This makes sure only one stream 85 is active at a time.*/ 86 struct pcm * activePcm = NULL; 87 /*TODO - move active channel inside activepcm*/ 88 static unsigned int activeChannel; 89 90 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 91 92 #define STRING_TO_ENUM(string) { #string, string } 93 94 struct channel_list { 95 const char *name; 96 uint32_t value; 97 }; 98 99 const struct channel_list channel_list_table[] = { 100 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO), 101 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1), 102 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1), 103 }; 104 105 struct pcm_config pcm_config_default = { 106 .channels = 2, 107 .rate = 44100, 108 .period_size = 1024, 109 .period_count = 4, 110 .format = PCM_FORMAT_S24_LE, 111 }; 112 113 #define CHANNEL_MASK_MAX 3 114 struct audio_device { 115 struct audio_hw_device hw_device; 116 117 pthread_mutex_t lock; 118 int card; 119 int device; 120 bool standby; 121 int sink_sup_channels; 122 audio_channel_mask_t sup_channel_masks[CHANNEL_MASK_MAX]; 123 }; 124 125 struct stream_out { 126 struct audio_stream_out stream; 127 128 pthread_mutex_t lock; 129 struct pcm *pcm; 130 bool standby; 131 132 /* PCM Stream Configurations */ 133 struct pcm_config pcm_config; 134 uint32_t channel_mask; 135 136 /* ALSA PCM Configurations */ 137 uint32_t sample_rate; 138 uint32_t buffer_size; 139 uint32_t channels; 140 uint32_t latency; 141 142 struct audio_device *dev; 143 }; 144 145 /** 146 * NOTE: when multiple mutexes have to be acquired, always respect the 147 * following order: hw device > out stream 148 */ 149 150 /* Helper functions */ 151 152 // This function return the card number associated with the card ID (name) 153 // passed as argument 154 static int get_card_number_by_name(const char* name) 155 { 156 char id_filepath[PATH_MAX] = {0}; 157 char number_filepath[PATH_MAX] = {0}; 158 ssize_t written; 159 160 snprintf(id_filepath, sizeof(id_filepath), "/proc/asound/%s", name); 161 162 written = readlink(id_filepath, number_filepath, sizeof(number_filepath)); 163 if (written < 0) { 164 ALOGE("Sound card %s does not exist - setting default", name); 165 return DEFAULT_CARD; 166 } else if (written >= (ssize_t)sizeof(id_filepath)) { 167 ALOGE("Sound card %s name is too long - setting default", name); 168 return DEFAULT_CARD; 169 } 170 171 // We are assured, because of the check in the previous elseif, that this 172 // buffer is null-terminated. So this call is safe. 173 // 4 == strlen("card") 174 return atoi(number_filepath + 4); 175 } 176 177 static enum pcm_format Get_SinkSupported_format() 178 { 179 /*TODO : query sink supported formats*/ 180 return PCM_FORMAT_S24_LE; 181 } 182 183 static int format_to_bits(enum pcm_format pcmformat) 184 { 185 switch (pcmformat) { 186 case PCM_FORMAT_S32_LE: 187 return 32; 188 case PCM_FORMAT_S24_LE: 189 return 24; 190 default: 191 case PCM_FORMAT_S16_LE: 192 return 16; 193 }; 194 } 195 196 static int make_sinkcompliant_buffers(void* input, void *output, int ipbytes) 197 { 198 int i = 0,outbytes = 0; 199 enum pcm_format in_pcmformat; 200 enum pcm_format out_pcmformat; 201 int *src = (int*)input; 202 int *dst = (int*)output; 203 204 /*by default android currently support only 205 16 bit signed PCM*/ 206 in_pcmformat = PCM_FORMAT_S16_LE; 207 out_pcmformat = Get_SinkSupported_format(); 208 209 switch (out_pcmformat) { 210 default: 211 case PCM_FORMAT_S24_LE: 212 { 213 ALOGV("convert 16 to 24 bits for %d",ipbytes); 214 /*convert 16 bit input to 24 bit output 215 in a 32 bit sample*/ 216 if(0 == ipbytes) 217 break; 218 219 for(i = 0; i < (ipbytes/4); i++){ 220 int x = (int)((int*)src)[i]; 221 dst[i*2] = ((int)( x & 0x0000FFFF)) << 8; 222 // trying to sign exdent 223 dst[i*2] = dst[i*2] << 8; 224 dst[i*2] = dst[i*2] >> 8; 225 //shift to middle 226 dst[i*2 + 1] = (int)(( x & 0xFFFF0000) >> 8); 227 dst[i*2 + 1] = dst[i*2 + 1] << 8; 228 dst[i*2 + 1] = dst[i*2 + 1] >> 8; 229 } 230 outbytes=ipbytes * 2; 231 232 }//case 233 };//switch 234 235 return outbytes; 236 } 237 238 /* must be called with hw device and output stream mutexes locked */ 239 static int start_output_stream(struct stream_out *out) 240 { 241 struct audio_device *adev = out->dev; 242 int hdmicard = 0; 243 244 ALOGV("%s enter",__func__); 245 246 if ((adev->card < 0) || (adev->device < 0)){ 247 /*this will be updated once the hot plug intent 248 sends these information.*/ 249 adev->card = DEFAULT_CARD; 250 adev->device = DEFAULT_DEVICE; 251 ALOGV("%s : Setting default card/ device %d,%d",__func__,adev->card,adev->device); 252 } 253 254 ALOGV("%s enter %d,%d,%d,%d,%d",__func__, 255 out->pcm_config.channels, 256 out->pcm_config.rate, 257 out->pcm_config.period_size, 258 out->pcm_config.period_count, 259 out->pcm_config.format); 260 261 out->pcm_config.start_threshold = 0; 262 out->pcm_config.stop_threshold = 0; 263 out->pcm_config.silence_threshold = 0; 264 265 if(activePcm){ 266 ALOGV("Closing already open tiny alsa stream running state %d",(int)(activePcm)); 267 pcm_close(activePcm); 268 activePcm = NULL; 269 } 270 271 /*TODO - this needs to be updated once the device connect intent sends 272 card, device id*/ 273 adev->card = get_card_number_by_name("IntelHDMI"); 274 ALOGD("%s: HDMI card number = %d, device = %d",__func__,adev->card,adev->device); 275 276 out->pcm = pcm_open(adev->card, adev->device, PCM_OUT, &out->pcm_config); 277 278 if (out->pcm && !pcm_is_ready(out->pcm)) { 279 ALOGE("pcm_open() failed: %s", pcm_get_error(out->pcm)); 280 pcm_close(out->pcm); 281 activePcm = NULL; 282 return -ENOMEM; 283 } 284 285 activePcm = out->pcm; 286 activeChannel = out->pcm_config.channels; 287 288 ALOGV("Initialized PCM device for channels %d handle = %d",out->pcm_config.channels, (int)activePcm); 289 ALOGV("%s exit",__func__); 290 return 0; 291 } 292 293 /* API functions */ 294 295 static uint32_t out_get_sample_rate(const struct audio_stream *stream) 296 { 297 struct stream_out *out = (struct stream_out *)stream; 298 return out->pcm_config.rate; 299 } 300 301 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate) 302 { 303 UNUSED_PARAMETER(stream); 304 UNUSED_PARAMETER(rate); 305 306 return 0; 307 } 308 309 static size_t out_get_buffer_size(const struct audio_stream *stream) 310 { 311 struct stream_out *out = (struct stream_out *)stream; 312 size_t buf_size; 313 314 if(out->channel_mask > 2){ 315 buf_size = out->pcm_config.period_size * 316 audio_stream_out_frame_size((struct audio_stream_out *)stream); 317 } 318 else{ 319 buf_size = out->pcm_config.period_size * 320 out->pcm_config.period_count * 321 audio_stream_out_frame_size((struct audio_stream_out *)stream); 322 323 /*latency of audio flinger is based on this 324 buffer size. modifying the buffer size to avoid 325 starvation*/ 326 buf_size/=LATENCY_TO_BUFFER_SIZE_RATIO; 327 } 328 329 ALOGV("%s : %d, period_size : %d, frame_size : %d", 330 __func__, 331 buf_size, 332 out->pcm_config.period_size, 333 audio_stream_out_frame_size((struct audio_stream_out *)stream)); 334 335 return buf_size; 336 337 } 338 339 static uint32_t out_get_channels(const struct audio_stream *stream) 340 { 341 struct stream_out *out = (struct stream_out *)stream; 342 ALOGV("%s channel mask : %x",__func__,out->channel_mask); 343 return out->channel_mask; 344 } 345 346 static audio_format_t out_get_format(const struct audio_stream *stream) 347 { 348 UNUSED_PARAMETER(stream); 349 350 return AUDIO_FORMAT_PCM_16_BIT; 351 } 352 353 static int out_set_format(struct audio_stream *stream, audio_format_t format) 354 { 355 UNUSED_PARAMETER(stream); 356 UNUSED_PARAMETER(format); 357 358 return 0; 359 } 360 361 static int out_standby(struct audio_stream *stream) 362 { 363 struct stream_out *out = (struct stream_out *)stream; 364 365 ALOGV("%s enter standby = %d",__func__,out->standby); 366 367 pthread_mutex_lock(&out->dev->lock); 368 pthread_mutex_lock(&out->lock); 369 370 if (!out->standby && activePcm) { 371 pcm_close(activePcm); 372 out->pcm = NULL; 373 out->standby = true; 374 activePcm = NULL; 375 ALOGV("%s PCM device closed",__func__); 376 } 377 378 pthread_mutex_unlock(&out->lock); 379 pthread_mutex_unlock(&out->dev->lock); 380 381 ALOGV("%s exit",__func__); 382 return 0; 383 } 384 385 static int out_dump(const struct audio_stream *stream, int fd) 386 { 387 UNUSED_PARAMETER(stream); 388 UNUSED_PARAMETER(fd); 389 return 0; 390 } 391 392 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) 393 { 394 struct stream_out *out = (struct stream_out *)stream; 395 struct audio_device *adev = out->dev; 396 struct str_parms *parms; 397 char value[32]; 398 int ret; 399 int routing = 0; 400 ALOGV("%s enter",__func__); 401 402 parms = str_parms_create_str(kvpairs); 403 404 pthread_mutex_lock(&adev->lock); 405 406 if (parms == NULL) { 407 ALOGE("couldn't extract string params from key value pairs"); 408 pthread_mutex_unlock(&adev->lock); 409 return 0; 410 } 411 412 ret = str_parms_get_str(parms, "card", value, sizeof(value)); 413 if (ret >= 0) 414 adev->card = atoi(value); 415 416 ret = str_parms_get_str(parms, "device", value, sizeof(value)); 417 if (ret >= 0) 418 adev->device = atoi(value); 419 420 pthread_mutex_unlock(&adev->lock); 421 str_parms_destroy(parms); 422 423 ALOGV("%s exit",__func__); 424 return 0; 425 } 426 427 static int parse_channel_map() 428 { 429 struct mixer *mixer; 430 int card = 0; 431 struct mixer_ctl *ctl; 432 enum mixer_ctl_type type; 433 unsigned int num_values; 434 unsigned int i,id; 435 int chcount=0, chmap=0; 436 437 card = get_card_number_by_name("IntelHDMI"); 438 mixer = mixer_open(card); 439 if (!mixer) { 440 ALOGE("[EDID] Failed to open mixer\n"); 441 goto chmap_error; 442 } 443 444 id = CHANNEL_MAP_REQUEST; 445 if (id >= mixer_get_num_ctls(mixer)) { 446 ALOGE("[EDID] Invalid request for channel map %d",id); 447 goto chmap_error; 448 } 449 450 ctl = mixer_get_ctl_by_name(mixer, "Playback Channel Map"); 451 452 //ctl = mixer_get_ctl(mixer, id); 453 454 type = mixer_ctl_get_type(ctl); 455 num_values = mixer_ctl_get_num_values(ctl); 456 457 ALOGV("[EDID]id = %d",id); 458 ALOGV("[EDID]type = %d",type); 459 ALOGV("[EDID]count = %d",num_values); 460 461 for (i = 0; i < num_values; i++) { 462 switch (type) 463 { 464 case MIXER_CTL_TYPE_INT: 465 chmap = mixer_ctl_get_value(ctl, i); 466 ALOGD("[EDID]chmap = %d", chmap); 467 if(chmap > 0) ++chcount; 468 break; 469 default: 470 printf(" unknown"); 471 break; 472 }; 473 }//for 474 475 ALOGD("[EDID]valid number of channels supported by sink = %d",chcount); 476 477 mixer_close(mixer); 478 479 return chcount; 480 481 chmap_error: 482 mixer_close(mixer); 483 return 2;//stereo by default 484 485 } 486 487 static int out_read_edid(const struct stream_out *stream) 488 { 489 struct stream_out *out = (struct stream_out *)stream; 490 struct audio_device *adev = out->dev; 491 492 /**read the channel max param from the sink*/ 493 adev->sink_sup_channels = parse_channel_map(); 494 495 if(adev->sink_sup_channels == 8) { 496 adev->sup_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1; 497 adev->sup_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1; 498 } 499 else if((adev->sink_sup_channels == 6) || (adev->sink_sup_channels > 2)) { 500 adev->sup_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1; 501 } 502 else { 503 adev->sup_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO; 504 } 505 506 ALOGV("%s sink supports 0x%x max channels", __func__,adev->sink_sup_channels); 507 return 0; 508 } 509 510 static char * out_get_parameters(const struct audio_stream *stream, const char *keys) 511 { 512 struct stream_out *out = (struct stream_out *)stream; 513 struct audio_device *adev = out->dev; 514 struct str_parms *params_in = str_parms_create_str(keys); 515 char *str = NULL; 516 char value[256] = {0}; 517 int ret; 518 size_t i, j; 519 bool append = false; 520 521 struct str_parms *params_out = str_parms_create(); 522 523 ALOGV("%s Entered %s", __func__,keys); 524 525 if (params_in) { 526 ret = str_parms_get_str(params_in, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value)); 527 if (ret >= 0) { 528 /*read the channel support from sink*/ 529 out_read_edid(out); 530 531 value[0] = '\0'; 532 for (i = 0; i < CHANNEL_MASK_MAX; i++) { 533 for (j = 0; j < ARRAY_SIZE(channel_list_table); j++) { 534 if (channel_list_table[j].value == adev->sup_channel_masks[i]) { 535 if (append) { 536 strcat(value, "|"); 537 } 538 strcat(value, channel_list_table[j].name); 539 append = true; 540 break; 541 } 542 } 543 } 544 } 545 } 546 if (params_out) { 547 str_parms_add_str(params_out, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value); 548 str = str_parms_to_str(params_out); 549 } else { 550 str = strdup(keys); 551 } 552 553 ALOGV("%s AUDIO_PARAMETER_STREAM_SUP_CHANNELS %s", __func__,str); 554 if (params_in) { 555 str_parms_destroy(params_in); 556 } 557 if (params_out) { 558 str_parms_destroy(params_out); 559 } 560 561 return str; 562 } 563 564 static uint32_t out_get_latency(const struct audio_stream_out *stream) 565 { 566 struct stream_out *out = (struct stream_out *)stream; 567 return (out->pcm_config.period_size * out->pcm_config.period_count * 1000) / 568 out_get_sample_rate(&stream->common); 569 } 570 571 static int out_set_volume(struct audio_stream_out *stream, float left, 572 float right) 573 { 574 UNUSED_PARAMETER(stream); 575 UNUSED_PARAMETER(left); 576 UNUSED_PARAMETER(right); 577 578 return -ENOSYS; 579 } 580 581 static ssize_t out_write(struct audio_stream_out *stream, const void* buffer, 582 size_t bytes) 583 { 584 int ret = 0; 585 struct stream_out *out = (struct stream_out *)stream; 586 int32_t* dstbuff = NULL; 587 int outbytes = 0; 588 589 ALOGV("%s enter for bytes = %d channels = %d",__func__,bytes, out->pcm_config.channels); 590 591 pthread_mutex_lock(&out->dev->lock); 592 pthread_mutex_lock(&out->lock); 593 594 if(activePcm == NULL) { 595 ALOGV("%s: previous stream closed- open again",__func__); 596 out->standby = true; 597 } 598 599 if (out->standby) { 600 ret = start_output_stream(out); 601 if (ret != 0) { 602 goto err; 603 } 604 out->standby = false; 605 } 606 607 if((!out->pcm) || (activeChannel != out->pcm_config.channels)){ 608 ALOGD("%s: null handle to write - device already closed",__func__); 609 goto err; 610 } 611 612 if(Get_SinkSupported_format() == out->pcm_config.format){ 613 614 /*16 bit data will be converted to 24 bit over 32 bit data type 615 hence the multiplier 2*/ 616 dstbuff = (int32_t*)malloc(bytes* 2); 617 if (!dstbuff) { 618 pthread_mutex_unlock(&out->lock); 619 pthread_mutex_unlock(&out->dev->lock); 620 ALOGE("%s : memory allocation failed",__func__); 621 return -ENOMEM; 622 } 623 624 memset(dstbuff,0,bytes * 2); 625 626 outbytes = make_sinkcompliant_buffers((void*)buffer, (void*)dstbuff,bytes); 627 } //if()for conversion 628 629 if(dstbuff){ 630 ret = pcm_write(out->pcm, (void *)dstbuff, outbytes); 631 } 632 else 633 ret = pcm_write(out->pcm, (void *)buffer, bytes); 634 635 ALOGV("pcm_write: %s done for %d input bytes, output bytes = %d ", pcm_get_error(out->pcm),bytes,outbytes); 636 637 free(dstbuff); 638 639 err: 640 pthread_mutex_unlock(&out->lock); 641 pthread_mutex_unlock(&out->dev->lock); 642 643 if(ret !=0){ 644 uint64_t duration_ms = ((bytes * 1000)/ 645 (audio_stream_out_frame_size(stream)) / 646 (out_get_sample_rate(&stream->common))); 647 ALOGV("%s : silence written", __func__); 648 usleep(duration_ms * 1000); 649 } 650 651 ALOGV("%s exit",__func__); 652 return bytes; 653 } 654 655 static int out_get_render_position(const struct audio_stream_out *stream, 656 uint32_t *dsp_frames) 657 { 658 UNUSED_PARAMETER(stream); 659 UNUSED_PARAMETER(dsp_frames); 660 661 return -EINVAL; 662 } 663 664 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) 665 { 666 UNUSED_PARAMETER(stream); 667 UNUSED_PARAMETER(effect); 668 669 return 0; 670 } 671 672 static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) 673 { 674 UNUSED_PARAMETER(stream); 675 UNUSED_PARAMETER(effect); 676 677 return 0; 678 } 679 680 static int out_get_next_write_timestamp(const struct audio_stream_out *stream, 681 int64_t *timestamp) 682 { 683 UNUSED_PARAMETER(stream); 684 UNUSED_PARAMETER(timestamp); 685 686 return -EINVAL; 687 } 688 689 static int adev_open_output_stream(struct audio_hw_device *dev, 690 audio_io_handle_t handle, 691 audio_devices_t devices, 692 audio_output_flags_t flags, 693 struct audio_config *config, 694 struct audio_stream_out **stream_out, 695 const char *address) 696 { 697 UNUSED_PARAMETER(devices); 698 UNUSED_PARAMETER(handle); 699 UNUSED_PARAMETER(address); 700 701 struct audio_device *adev = (struct audio_device *)dev; 702 struct stream_out *out; 703 int ret; 704 ALOGV("%s enter",__func__); 705 706 out = (struct stream_out *)calloc(1, sizeof(struct stream_out)); 707 if (!out) 708 return -ENOMEM; 709 710 711 out->dev = adev; 712 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO; 713 adev->sup_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO; 714 715 if (flags & AUDIO_OUTPUT_FLAG_DIRECT) { 716 ALOGV("%s: HDMI Multichannel",__func__); 717 if (config->sample_rate == 0) 718 config->sample_rate = pcm_config_default.rate; 719 if (config->channel_mask == 0){ 720 /*read the channel support from sink*/ 721 out_read_edid(out); 722 if(config->channel_mask == 0) 723 config->channel_mask = AUDIO_CHANNEL_OUT_5POINT1; 724 } 725 } else { 726 ALOGV("%s: HDMI Stereo",__func__); 727 if (config->sample_rate == 0) 728 config->sample_rate = pcm_config_default.rate; 729 if (config->channel_mask == 0) 730 config->channel_mask = AUDIO_CHANNEL_OUT_STEREO; 731 } 732 733 out->channel_mask = config->channel_mask; 734 735 out->pcm_config.channels = popcount(config->channel_mask); 736 out->pcm_config.rate = config->sample_rate; 737 out->pcm_config.period_size = pcm_config_default.period_size; 738 out->pcm_config.period_count = pcm_config_default.period_count; 739 out->pcm_config.format = pcm_config_default.format; 740 741 out->stream.common.get_sample_rate = out_get_sample_rate; 742 out->stream.common.set_sample_rate = out_set_sample_rate; 743 out->stream.common.get_buffer_size = out_get_buffer_size; 744 out->stream.common.get_channels = out_get_channels; 745 out->stream.common.get_format = out_get_format; 746 out->stream.common.set_format = out_set_format; 747 out->stream.common.standby = out_standby; 748 out->stream.common.dump = out_dump; 749 out->stream.common.set_parameters = out_set_parameters; 750 out->stream.common.get_parameters = out_get_parameters; 751 out->stream.common.add_audio_effect = out_add_audio_effect; 752 out->stream.common.remove_audio_effect = out_remove_audio_effect; 753 out->stream.get_latency = out_get_latency; 754 out->stream.set_volume = out_set_volume; 755 out->stream.write = out_write; 756 out->stream.get_render_position = out_get_render_position; 757 out->stream.get_next_write_timestamp = out_get_next_write_timestamp; 758 759 config->format = out_get_format(&out->stream.common); 760 config->channel_mask = out_get_channels(&out->stream.common); 761 config->sample_rate = out_get_sample_rate(&out->stream.common); 762 763 out->standby = true; 764 765 adev->card = -1; 766 adev->device = -1; 767 768 pthread_mutex_lock(&out->dev->lock); 769 pthread_mutex_lock(&out->lock); 770 771 if(activePcm){ 772 ALOGV("Closing already open tiny alsa stream %d",(int)out->pcm); 773 pcm_close(activePcm); 774 activePcm = NULL; 775 } 776 ret = start_output_stream(out); 777 if (ret != 0) { 778 ALOGV("%s: stream start failed", __func__); 779 goto err_open; 780 } 781 782 out->standby = false; 783 784 *stream_out = &out->stream; 785 786 pthread_mutex_unlock(&out->lock); 787 pthread_mutex_unlock(&out->dev->lock); 788 789 ALOGV("%s exit",__func__); 790 return 0; 791 792 err_open: 793 ALOGE("%s exit with error",__func__); 794 pthread_mutex_unlock(&out->lock); 795 pthread_mutex_unlock(&out->dev->lock); 796 free(out); 797 *stream_out = NULL; 798 return ret; 799 } 800 801 static void adev_close_output_stream(struct audio_hw_device *dev, 802 struct audio_stream_out *stream) 803 { 804 UNUSED_PARAMETER(dev); 805 806 struct stream_out *out = (struct stream_out *)stream; 807 808 ALOGV("%s enter",__func__); 809 out->standby = false; 810 out_standby(&stream->common); 811 free(stream); 812 ALOGV("%s exit",__func__); 813 } 814 815 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs) 816 { 817 UNUSED_PARAMETER(dev); 818 UNUSED_PARAMETER(kvpairs); 819 820 return 0; 821 } 822 823 static char * adev_get_parameters(const struct audio_hw_device *dev, 824 const char *keys) 825 { 826 UNUSED_PARAMETER(dev); 827 UNUSED_PARAMETER(keys); 828 829 return strdup(""); 830 } 831 832 static int adev_init_check(const struct audio_hw_device *dev) 833 { 834 UNUSED_PARAMETER(dev); 835 836 return 0; 837 } 838 839 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume) 840 { 841 UNUSED_PARAMETER(dev); 842 UNUSED_PARAMETER(volume); 843 844 return -ENOSYS; 845 } 846 847 static int adev_set_master_volume(struct audio_hw_device *dev, float volume) 848 { 849 UNUSED_PARAMETER(dev); 850 UNUSED_PARAMETER(volume); 851 852 return -ENOSYS; 853 } 854 855 static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode) 856 { 857 UNUSED_PARAMETER(dev); 858 UNUSED_PARAMETER(mode); 859 860 return 0; 861 } 862 863 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state) 864 { 865 UNUSED_PARAMETER(dev); 866 UNUSED_PARAMETER(state); 867 868 return -ENOSYS; 869 } 870 871 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) 872 { 873 UNUSED_PARAMETER(dev); 874 UNUSED_PARAMETER(state); 875 876 return -ENOSYS; 877 } 878 879 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev, 880 const struct audio_config *config) 881 { 882 UNUSED_PARAMETER(dev); 883 UNUSED_PARAMETER(config); 884 885 return 0; 886 } 887 888 static int adev_open_input_stream(struct audio_hw_device *dev, 889 audio_io_handle_t handle, 890 audio_devices_t devices, 891 struct audio_config *config, 892 struct audio_stream_in **stream_in, 893 audio_input_flags_t flags, 894 const char *address, 895 audio_source_t source) 896 { 897 UNUSED_PARAMETER(dev); 898 UNUSED_PARAMETER(handle); 899 UNUSED_PARAMETER(devices); 900 UNUSED_PARAMETER(config); 901 UNUSED_PARAMETER(stream_in); 902 UNUSED_PARAMETER(flags); 903 UNUSED_PARAMETER(address); 904 UNUSED_PARAMETER(source); 905 906 return -ENOSYS; 907 } 908 909 static void adev_close_input_stream(struct audio_hw_device *dev, 910 struct audio_stream_in *stream) 911 { 912 UNUSED_PARAMETER(dev); 913 UNUSED_PARAMETER(stream); 914 } 915 916 static int adev_dump(const audio_hw_device_t *device, int fd) 917 { 918 UNUSED_PARAMETER(device); 919 UNUSED_PARAMETER(fd); 920 921 return 0; 922 } 923 924 static int adev_close(hw_device_t *device) 925 { 926 struct audio_device *adev = (struct audio_device *)device; 927 928 free(device); 929 return 0; 930 } 931 932 static int adev_open(const hw_module_t* module, const char* name, 933 hw_device_t** device) 934 { 935 struct audio_device *adev; 936 int ret; 937 938 ALOGV("%s enter",__func__); 939 940 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) 941 return -EINVAL; 942 943 adev = calloc(1, sizeof(struct audio_device)); 944 if (!adev) 945 return -ENOMEM; 946 947 adev->hw_device.common.tag = HARDWARE_DEVICE_TAG; 948 adev->hw_device.common.version = AUDIO_DEVICE_API_VERSION_2_0; 949 adev->hw_device.common.module = (struct hw_module_t *) module; 950 adev->hw_device.common.close = adev_close; 951 952 adev->hw_device.init_check = adev_init_check; 953 adev->hw_device.set_voice_volume = adev_set_voice_volume; 954 adev->hw_device.set_master_volume = adev_set_master_volume; 955 adev->hw_device.set_mode = adev_set_mode; 956 adev->hw_device.set_mic_mute = adev_set_mic_mute; 957 adev->hw_device.get_mic_mute = adev_get_mic_mute; 958 adev->hw_device.set_parameters = adev_set_parameters; 959 adev->hw_device.get_parameters = adev_get_parameters; 960 adev->hw_device.get_input_buffer_size = adev_get_input_buffer_size; 961 adev->hw_device.open_output_stream = adev_open_output_stream; 962 adev->hw_device.close_output_stream = adev_close_output_stream; 963 adev->hw_device.open_input_stream = adev_open_input_stream; 964 adev->hw_device.close_input_stream = adev_close_input_stream; 965 adev->hw_device.dump = adev_dump; 966 967 *device = &adev->hw_device.common; 968 969 ALOGV("%s exit",__func__); 970 971 return 0; 972 } 973 974 static struct hw_module_methods_t hal_module_methods = { 975 .open = adev_open, 976 }; 977 978 struct audio_module HAL_MODULE_INFO_SYM = { 979 .common = { 980 .tag = HARDWARE_MODULE_TAG, 981 .module_api_version = AUDIO_MODULE_API_VERSION_0_1, 982 .hal_api_version = HARDWARE_HAL_API_VERSION, 983 .id = AUDIO_HARDWARE_MODULE_ID, 984 .name = "tiny_hdmi audio HW HAL", 985 .author = "The Android Open Source Project", 986 .methods = &hal_module_methods, 987 }, 988 }; 989