audioomx.cc

   1 /*
   2     Copyright 2004-2005 Chris Tallon, 2009 Marten Richter
   3
   4     This file is part of VOMP.
   5
   6     VOMP 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     VOMP 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
  17     along with VOMP; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 */
  20
  21 #include "audioomx.h"
  22 #include "videoomx.h"
  23 #include "log.h"
  24 #include "vdr.h"
  25 #include "woptionpane.h"
  26
  27 #include "osdopenvg.h"
  28 #include <bcm_host.h>
  29
  30 AudioOMX::AudioOMX()
  31 {
  32   initted = 0;
  33   streamType = 0;
  34   volume = 20;
  35   muted = 0;
  36   lastAType = MPTYPE_MPEG_AUDIO;
  37
  38   canpass_ac3=false;
  39   canpass_mp2=false;
  40   canpass_mp3=false;
  41   canpass_aac=false;
  42   canpass_pcm_mch=false;
  43
  44   prefered_ac3=0; //0 stereo PCM, 1 passthrough 2 Multichannel PCM
  45   prefered_mp2=0;
  46   prefered_mp3=0;
  47   prefered_aac=0;
  48   hdmi=true;
  49
  50   omx_running=false;
  51
  52   omx_aud_rend/*dec*/=0;
  53   cur_input_buf_omx=NULL;
  54
  55   ac3codec_libav=NULL;
  56   ac3codec_context_libav=NULL;
  57
  58   mp23codec_libav=NULL;
  59   mp23codec_context_libav=NULL;
  60 #ifdef USE_LIBRESAMPLE
  61   resam_con_libav=NULL;
  62 #endif
  63
  64   decompress_buffer=NULL;
  65   decompress_buffer_size=0;
  66   decompress_buffer_filled=0;
  67
  68 }
  69
  70 AudioOMX::~AudioOMX()
  71 {
  72 }
  73
  74 int AudioOMX::init(UCHAR tstreamType) {
  75         if (initted)
  76                 return 0;
  77         initted = 1;
  78
  79         streamType = tstreamType;
  80
  81         if (!initAllParams()) {
  82                 shutdown();
  83                 return 0;
  84         }
  85
  86         unMute();
  87
  88         decompress_buffer_size=20000;
  89         decompress_buffer=(UCHAR*)malloc(decompress_buffer_size);
  90         decompress_buffer_filled=0;
  91
  92
  93
  94         av_register_all();
  95         av_log_set_flags(AV_LOG_SKIP_REPEATED);
  96
  97         ac3codec_libav = avcodec_find_decoder(CODEC_ID_AC3);
  98         if (ac3codec_libav == NULL) {
  99                 Log::getInstance()->log("Audio", Log::DEBUG,
 100                                 "Find libav ac3 decoder failed");
 101                 return 0;
 102         }
 103
 104         mp23codec_libav = avcodec_find_decoder(CODEC_ID_MP3);
 105         if (mp23codec_libav == NULL) {
 106                 Log::getInstance()->log("Audio", Log::DEBUG,
 107                                 "Find libav mpeg audio decoder failed");
 108                 return 0;
 109         }
 110
 111         aaclatmcodec_libav = avcodec_find_decoder(CODEC_ID_AAC_LATM);
 112         if (aaclatmcodec_libav == NULL) {
 113                 Log::getInstance()->log("Audio", Log::DEBUG,
 114                                 "Find libav aac latm decoder failed");
 115                 return 0;
 116         }
 117
 118         int ret;
 119
 120         ret=vc_tv_hdmi_audio_supported( EDID_AudioFormat_eMPEG1,2,EDID_AudioSampleRate_e48KHz,0);
 121         if (ret==0) {
 122                 //canpass_mp2=true;
 123                 // not implemented
 124                 Log::getInstance()->log("Audio", Log::NOTICE,
 125                                                 "TV hdmi supports mpeg1 layer 1 and 2");
 126         }
 127         ret=vc_tv_hdmi_audio_supported( EDID_AudioFormat_eMP3,2,EDID_AudioSampleRate_e48KHz,0);
 128         if (ret==0) {
 129                 //canpass_mp3=true;
 130                 // not implemented
 131                 Log::getInstance()->log("Audio", Log::NOTICE,
 132                                                 "TV hdmi supports mpeg1 layer 3");
 133         }
 134
 135         ret=vc_tv_hdmi_audio_supported( EDID_AudioFormat_eAC3,6,EDID_AudioSampleRate_e48KHz,0);
 136         if (ret==0) {
 137                 canpass_ac3=true;
 138                 Log::getInstance()->log("Audio", Log::NOTICE,
 139                                                 "TV hdmi supports AC3");
 140         }
 141         ret=vc_tv_hdmi_audio_supported( EDID_AudioFormat_eAAC,6,EDID_AudioSampleRate_e48KHz,0);
 142         if (ret==0) {
 143                 canpass_aac=true;
 144                 //not implemented
 145                 Log::getInstance()->log("Audio", Log::NOTICE,
 146                                 "TV hdmi supports AAC");
 147         }
 148
 149         canpass_pcm_mch=false;
 150
 151         return 1;
 152 }
 153
 154 int AudioOMX::initAllParams()
 155 {
 156   return (setStreamType(streamType) && setChannel() && setSource());
 157 }
 158
 159 int AudioOMX::shutdown()
 160 {
 161   if (!initted) return 0;
 162   initted = 0;
 163
 164   Log::getInstance()->log("Audio", Log::DEBUG, "audio shutdown called");
 165   DeAllocateCodecsOMX();
 166
 167   free(decompress_buffer);
 168   decompress_buffer=NULL;
 169   decompress_buffer_size=0;
 170   decompress_buffer_filled=0;
 171
 172   return 1;
 173 }
 174
 175 bool AudioOMX::loadOptionsfromServer(VDR* vdr)
 176 {
 177           Log::getInstance()->log("Audio", Log::DEBUG, "AudioOMX config load");
 178     char *name=vdr->configLoad("AudioOMX","AC3DecodingMode");
 179
 180     if (name != NULL) {
 181                 if (STRCASECMP(name, "PCM") == 0) {
 182                         prefered_ac3 = 0;
 183                 } else if (STRCASECMP(name, "Passthrough") == 0) {
 184                         prefered_ac3 = 1;
 185                 } else if (STRCASECMP(name, "PCMMultichannel") == 0) {
 186                         prefered_ac3 = 2;
 187                 }
 188         }
 189
 190     name = vdr->configLoad("AudioOMX", "Mp2DecodingMode");
 191
 192         if (name != NULL) {
 193                 if (STRCASECMP(name, "PCM") == 0) {
 194                         prefered_mp2 = 0;
 195                 } else if (STRCASECMP(name, "Passthrough") == 0) {
 196                         prefered_mp2 = 1;
 197                 } else if (STRCASECMP(name, "PCMMultichannel") == 0) {
 198                         prefered_mp2 = 2;
 199                 }
 200         }
 201
 202         name = vdr->configLoad("AudioOMX", "AACDecodingMode");
 203
 204         if (name != NULL) {
 205                 if (STRCASECMP(name, "PCM") == 0) {
 206                         prefered_aac = 0;
 207                 } else if (STRCASECMP(name, "Passthrough") == 0) {
 208                         prefered_aac = 1;
 209                 } else if (STRCASECMP(name, "PCMMultichannel") == 0) {
 210                         prefered_aac = 2;
 211                 }
 212         }
 213
 214         name = vdr->configLoad("AudioOMX", "Mp3DecodingMode");
 215
 216         if (name != NULL) {
 217                 if (STRCASECMP(name, "PCM") == 0) {
 218                         prefered_mp3 = 0;
 219                 } else if (STRCASECMP(name, "Passthrough") == 0) {
 220                         prefered_mp3 = 1;
 221                 } else if (STRCASECMP(name, "PCMMultichannel") == 0) {
 222                         prefered_mp3 = 2;
 223                 }
 224         }
 225
 226         name = vdr->configLoad("AudioOMX", "AudioOutput");
 227
 228         if (name != NULL) {
 229                 if (STRCASECMP(name, "analog") == 0) {
 230                         hdmi = false;
 231                 } else if (STRCASECMP(name, "HDMI") == 0) {
 232                         hdmi = true;
 233                 }
 234         }
 235
 236
 237    return true;
 238
 239 }
 240
 241 bool AudioOMX::handleOptionChanges(Option* option)
 242 {
 243     if (Audio::handleOptionChanges(option))
 244                 return true;
 245         switch (option->id) {
 246         case 4: {
 247                 if (STRCASECMP(option->options[option->userSetChoice], "analog") == 0) {
 248                         hdmi = false;
 249                 } else if (STRCASECMP(option->options[option->userSetChoice], "HDMI")
 250                                 == 0) {
 251                         hdmi = true;
 252                 }
 253                 return true;
 254         }
 255                 break;
 256         case 1: {
 257                 if (STRCASECMP(option->options[option->userSetChoice], "PCM") == 0) {
 258                         prefered_ac3 = 0;
 259                 } else if (STRCASECMP(option->options[option->userSetChoice],
 260                                 "Passthrough") == 0) {
 261                         prefered_ac3 = 1;
 262                 } else if (STRCASECMP(option->options[option->userSetChoice],
 263                                 "PCMMultichannel") == 0) {
 264                         prefered_ac3 = 2;
 265                 }
 266         }
 267                 break;
 268         case 2: {
 269                 if (STRCASECMP(option->options[option->userSetChoice], "PCM") == 0) {
 270                         prefered_mp2 = 0;
 271                 } else if (STRCASECMP(option->options[option->userSetChoice],
 272                                 "Passthrough") == 0) {
 273                         prefered_mp2 = 1;
 274                 } else if (STRCASECMP(option->options[option->userSetChoice],
 275                                 "PCMMultichannel") == 0) {
 276                         prefered_mp2 = 2;
 277                 }
 278         }
 279                 break;
 280         case 3: {
 281                 if (STRCASECMP(option->options[option->userSetChoice], "PCM") == 0) {
 282                         prefered_mp3 = 0;
 283                 } else if (STRCASECMP(option->options[option->userSetChoice],
 284                                 "Passthrough") == 0) {
 285                         prefered_mp3 = 1;
 286                 } else if (STRCASECMP(option->options[option->userSetChoice],
 287                                 "PCMMultichannel") == 0) {
 288                         prefered_mp3 = 2;
 289                 }
 290         }
 291                 break;
 292         case 5: {
 293                 if (STRCASECMP(option->options[option->userSetChoice], "PCM") == 0) {
 294                         prefered_aac = 0;
 295                 } else if (STRCASECMP(option->options[option->userSetChoice],
 296                                 "Passthrough") == 0) {
 297                         prefered_aac = 1;
 298                 } else if (STRCASECMP(option->options[option->userSetChoice],
 299                                 "PCMMultichannel") == 0) {
 300                         prefered_aac = 2;
 301                 }
 302         }
 303         break;
 304         };
 305         return false;
 306
 307 }
 308
 309 bool AudioOMX::saveOptionstoServer()
 310 {
 311
 312     switch (prefered_ac3) {
 313         case 0:
 314                 VDR::getInstance()->configSave("AudioOMX", "AC3DecodingMode", "PCM");
 315                 break;
 316         case 1:
 317                 VDR::getInstance()->configSave("AudioOMX", "AC3DecodingMode",
 318                                 "Passthrough");
 319                 break;
 320         case 2:
 321                 VDR::getInstance()->configSave("AudioOMX", "AC3DecodingMode",
 322                                 "PCMMultichannel");
 323                 break;
 324         };
 325
 326     switch (prefered_aac) {
 327         case 0:
 328                 VDR::getInstance()->configSave("AudioOMX", "AACDecodingMode", "PCM");
 329                 break;
 330         case 1:
 331                 VDR::getInstance()->configSave("AudioOMX", "AACDecodingMode",
 332                                 "Passthrough");
 333                 break;
 334         case 2:
 335                 VDR::getInstance()->configSave("AudioOMX", "AACDecodingMode",
 336                                 "PCMMultichannel");
 337                 break;
 338         };
 339
 340         switch (prefered_mp2) {
 341         case 0:
 342                 VDR::getInstance()->configSave("AudioOMX", "Mp2DecodingMode", "PCM");
 343                 break;
 344         case 1:
 345                 VDR::getInstance()->configSave("AudioOMX", "Mp2DecodingMode",
 346                                 "Passthrough");
 347                 break;
 348         case 2:
 349                 VDR::getInstance()->configSave("AudioOMX", "Mp2DecodingMode",
 350                                 "PCMMultichannel");
 351                 break;
 352         };
 353
 354         switch (prefered_mp3) {
 355         case 0:
 356                 VDR::getInstance()->configSave("AudioOMX", "Mp3DecodingMode", "PCM");
 357                 break;
 358         case 1:
 359                 VDR::getInstance()->configSave("AudioOMX", "Mp3DecodingMode",
 360                                 "Passthrough");
 361                 break;
 362         case 2:
 363                 VDR::getInstance()->configSave("AudioOMX", "Mp3DecodingMode",
 364                                 "PCMMultichannel");
 365                 break;
 366         };
 367
 368         if (!hdmi)
 369                 VDR::getInstance()->configSave("AudioOMX", "AudioOutput", "analog");
 370         else
 371                 VDR::getInstance()->configSave("AudioOMX", "AudioOutput", "HDMI");
 372
 373
 374     return true;
 375 }
 376
 377 /*Option(UINT id, const char* displayText, const char* configSection, const char* configKey, UINT optionType,
 378            UINT numChoices, UINT defaultChoice, UINT startInt,
 379            const char * const * options, const char * const * optionkeys = NULL, AbstractOption* handler=NULL);*/
 380
 381 bool AudioOMX::addOptionsToPanes(int panenumber,Options *options,WOptionPane* pane)
 382 {
 383     if (!Audio::addOptionsToPanes(panenumber,options,pane)) return false;
 384
 385
 386     Option* option;
 387     if (panenumber == 2)
 388     {
 389
 390         static const char* audioopts[]={"analog","HDMI"};
 391         option = new Option(4,tr("Audio Output"), "AudioOMX","AudioOutput",Option::TYPE_TEXT,2,0,0,audioopts,NULL,false,this);
 392         options->push_back(option);
 393         pane->addOptionLine(option);
 394
 395
 396         char **ac3opts=new char *[3];
 397         int i=0;
 398         ac3opts[i]=new char[strlen("PCM")+1];
 399         strcpy(ac3opts[i],"PCM");
 400         i++;
 401         if (canpass_ac3) {
 402                 ac3opts[i]=new char[strlen("Passthrough")+1];
 403             strcpy(ac3opts[i],"PassThrough");
 404             i++;
 405         }
 406         if (canpass_pcm_mch) {
 407                 ac3opts[i]=new char[strlen("PCMMultichannel")+1];
 408             strcpy(ac3opts[i],"PCMMultichannel");
 409             i++;
 410         }
 411         option = new Option(1 ,tr("AC3 HDMI Mode"), "AudioOMX", "AC3DecodingMode", Option::TYPE_TEXT, i, 0, 0, ac3opts,NULL,true, this);
 412         options->push_back(option);
 413         pane->addOptionLine(option);
 414
 415  /*       char **aacopts = new char *[3];
 416         i = 0;
 417         aacopts[i] = new char[strlen("PCM") + 1];
 418         strcpy(mp2opts[i], "PCM");
 419         i++;
 420         if (canpass_aac) {
 421                 aacopts[i] = new char[strlen("Passthrough") + 1];
 422                 strcpy(aacopts[i], "PassThrough");
 423                 i++;
 424         }
 425         if (canpass_pcm_mch) {
 426                 aacopts[i] = new char[strlen("PCMMultichannel") + 1];
 427                 strcpy(aacopts[i], "PCMMultichannel");
 428                 i++;
 429         }
 430         option = new Option(5, tr("Mp2 HDMI Mode"), "AudioOMX",
 431                         "AACDecodingMode", Option::TYPE_TEXT, i, 0, 0,
 432                         aacopts, NULL, true, this);
 433         options->push_back(option);
 434         pane->addOptionLine(option);
 435
 436
 437         char **mp2opts = new char *[3];
 438                 i = 0;
 439                 mp2opts[i] = new char[strlen("PCM") + 1];
 440                 strcpy(mp2opts[i], "PCM");
 441                 i++;
 442                 if (canpass_mp2) {
 443                         mp2opts[i] = new char[strlen("Passthrough") + 1];
 444                         strcpy(mp2opts[i], "PassThrough");
 445                         i++;
 446                 }
 447                 if (canpass_pcm_mch) {
 448                         mp2opts[i] = new char[strlen("PCMMultichannel") + 1];
 449                         strcpy(mp2opts[i], "PCMMultichannel");
 450                         i++;
 451                 }
 452                 option = new Option(2, tr("Mp2 HDMI Mode"), "AudioOMX",
 453                                 "Mp2DecodingMode", Option::TYPE_TEXT, i, 0, 0,
 454                                 mp2opts, NULL, true, this);
 455                 options->push_back(option);
 456                 pane->addOptionLine(option);
 457
 458                 char **mp3opts = new char *[3];
 459                 i = 0;
 460                 mp3opts[i] = new char[strlen("PCM") + 1];
 461                 strcpy(mp3opts[i], "PCM");
 462                 i++;
 463                 if (canpass_mp3) {
 464                         mp3opts[i] = new char[strlen("Passthrough") + 1];
 465                         strcpy(mp3opts[i], "PassThrough");
 466                         i++;
 467                 }
 468                 if (canpass_pcm_mch) {
 469                         mp3opts[i] = new char[strlen("PCMMultichannel") + 1];
 470                         strcpy(mp3opts[i], "PCMMultichannel");
 471                         i++;
 472                 }
 473                 option = new Option(3, tr("Mp3 HDMI Mode"), "AudioOMX",
 474                                 "Mp2DecodingMode", Option::TYPE_TEXT, i, 0, 0, mp3opts,
 475                                 NULL, true, this);
 476                 options->push_back(option);
 477                 pane->addOptionLine(option);*/
 478         // Comment unsupported modes out
 479
 480
 481     }
 482
 483     return true;
 484 }
 485
 486
 487
 488
 489
 490
 491 OMX_ERRORTYPE AudioOMX::EmptyBufferDone_OMX(OMX_IN OMX_HANDLETYPE hcomp,OMX_IN OMX_PTR appdata,OMX_IN OMX_BUFFERHEADERTYPE* buffer){
 492
 493         //Log::getInstance()->log("Audio", Log::NOTICE, "EmptyBufferDone");
 494         AudioOMX *audio=(AudioOMX *)getInstance();
 495         audio->ReturnEmptyOMXBuffer(buffer);
 496         return OMX_ErrorNone;
 497
 498 }
 499
 500 void AudioOMX::ReturnEmptyOMXBuffer(OMX_BUFFERHEADERTYPE* buffer){
 501         input_bufs_omx_mutex.Lock();
 502         //Log::getInstance()->log("Audio", Log::NOTICE, "ReturnEmptyOMXBuffer %d",input_bufs_omx_free.size());
 503         input_bufs_omx_free.push_back(buffer);
 504         //Log::getInstance()->log("Audio", Log::NOTICE, "ReturnEmptyOMXBuffer %d",input_bufs_omx_free.size());
 505         input_bufs_omx_mutex.Unlock();
 506 }
 507
 508  OMX_ERRORTYPE AudioOMX::FillBufferDone_OMX(OMX_IN OMX_HANDLETYPE hcomp, OMX_IN OMX_PTR appdata,OMX_IN OMX_BUFFERHEADERTYPE* buffer) {
 509          Log::getInstance()->log("Audio", Log::NOTICE, "FillBufferDone");
 510         return OMX_ErrorNone;
 511 }
 512
 513
 514
 515 int AudioOMX::setStreamType(UCHAR type)
 516 {
 517   if (!initted) return 0;
 518
 519  // if (ioctl(fdAudio, AV_SET_AUD_STREAMTYPE, type) != 0) return 0;
 520   return 1;
 521 }
 522
 523 int AudioOMX::setChannel()
 524 {
 525   if (!initted) return 0;
 526
 527  // if (ioctl(fdAudio, AV_SET_AUD_CHANNEL, 0) != 0) return 0;
 528   return 1;
 529 }
 530
 531 int AudioOMX::setSource()
 532 {
 533   if (!initted) return 0;
 534
 535  // if (ioctl(fdAudio, AV_SET_AUD_SRC, 1) != 0) return 0;
 536   return 1;
 537 }
 538
 539 int AudioOMX::sync()
 540 {
 541   if (!initted) return 0;
 542
 543  // if (ioctl(fdAudio, AV_SET_AUD_SYNC, 2) != 0) return 0;
 544   return 1;
 545 }
 546
 547 int AudioOMX::play() {
 548         if (!initted)
 549                 return 0;
 550         lastAType=MPTYPE_MPEG_AUDIO;
 551         Log::getInstance()->log("Audio", Log::DEBUG, "enter play");
 552
 553         ((VideoOMX*)Video::getInstance())->interlaceSwitch4Demux(); // switch resolution if necessary
 554
 555         if (!AllocateCodecsOMX()) {
 556                 return 0;
 557         }
 558         return 1;
 559 }
 560
 561
 562 int AudioOMX::ChangeAudioDestination() //clock aka omx mutex needs to be locked
 563 {
 564         OMX_ERRORTYPE error;
 565         const char * destinations[]={"local","hdmi"};
 566         int dest=0;
 567         if (hdmi) dest=1;
 568         else dest=0;
 569
 570         OMX_CONFIG_BRCMAUDIODESTINATIONTYPE auddest;
 571         memset(&auddest,0,sizeof(auddest));
 572         auddest.nSize=sizeof(auddest);
 573         auddest.nVersion.nVersion=OMX_VERSION;
 574         strcpy((char *)auddest.sName, destinations[dest]);
 575
 576         Log::getInstance()->log("Audio", Log::DEBUG, "setting destination to: %s",auddest.sName);
 577         error=OMX_SetConfig(omx_aud_rend,OMX_IndexConfigBrcmAudioDestination,&auddest);
 578         if (error!=OMX_ErrorNone){
 579                 Log::getInstance()->log("Audio", Log::DEBUG, "Init OMX_IndexConfigBrcmAudioDestination failed %x %x %s", error,omx_aud_rend,auddest.sName);
 580                 DeAllocateCodecsOMX();
 581                 return 0;
 582         }
 583         return 1;
 584
 585
 586 }
 587
 588 int AudioOMX::ChangeAudioPortConfig(bool disport) //clock aka omx mutex needs to be locked
 589 {
 590         OMX_ERRORTYPE error;
 591         //Ok first fidle a working configuration
 592         Log::getInstance()->log("Audio", Log::DEBUG,
 593                                                         "ChangeAudioPortConfig");
 594
 595         OMX_AUDIO_CODINGTYPE encoding;
 596         if (hdmi) {
 597                 switch (lastAType) {
 598                 case MPTYPE_MPEG_AUDIO: {
 599                         if (prefered_mp2 == 2 && false) { //not supported yet
 600
 601                         } else {
 602                                 if (prefered_mp2 == 1 && canpass_mp2) {
 603                                         passthrough = true;
 604                                         encoding=OMX_AUDIO_CodingMP3;
 605                                 } else {
 606                                         passthrough = false;
 607                                         encoding=OMX_AUDIO_CodingPCM;
 608                                 }
 609                         }
 610                 }
 611                         break;
 612                 case MPTYPE_AAC_LATM: {
 613                         if (prefered_aac == 2 && false) { //not supported yet
 614
 615                         } else {
 616                                 Log::getInstance()->log("Audio", Log::DEBUG,
 617                                                 "ChangeAudioPortConfig debug %d %d",prefered_aac,canpass_aac);
 618                                 if (prefered_aac == 1 && canpass_aac) {
 619                                         passthrough = true;
 620                                         encoding=OMX_AUDIO_CodingAAC;
 621                                 } else {
 622                                         passthrough = false;
 623                                         encoding=OMX_AUDIO_CodingPCM;
 624                                 }
 625                         }
 626                 }
 627                 break;
 628                 case MPTYPE_AC3_PRE13:
 629                 case MPTYPE_AC3: {
 630                         if (prefered_ac3 == 2 && false) { //not supported yet
 631
 632                         } else {
 633                                 Log::getInstance()->log("Audio", Log::DEBUG,
 634                                                                                         "ChangeAudioPortConfig debug %d %d",prefered_ac3,canpass_ac3);
 635                                 if (prefered_ac3 == 1 && canpass_ac3) {
 636                                         passthrough = true;
 637                                         encoding=OMX_AUDIO_CodingDDP;
 638                                 } else {
 639                                         passthrough = false;
 640                                         encoding=OMX_AUDIO_CodingPCM;
 641                                 }
 642                         }
 643                 }
 644                         break;
 645                 case MPTYPE_MPEG_AUDIO_LAYER3: {
 646                         if (prefered_mp3 == 2 && false) { //not supported yet
 647
 648                         } else {
 649                                 if (prefered_mp3 == 1 && canpass_mp2) {
 650                                         passthrough = true;
 651                                         encoding=OMX_AUDIO_CodingMP3;
 652                                 } else {
 653                                         passthrough = false;
 654                                         encoding=OMX_AUDIO_CodingPCM;
 655                                 }
 656                         }
 657                 }
 658                         break;
 659                 };
 660         } else {
 661                  passthrough=false;
 662                  encoding=OMX_AUDIO_CodingPCM;
 663                  //mch=false; // multichannel also false
 664         }
 665
 666
 667
 668         /*OMX_CONFIG_BOOLEANTYPE booly;
 669         memset(&booly, 0, sizeof(booly));
 670         booly.nSize = sizeof(booly);
 671         booly.nVersion.nVersion = OMX_VERSION;
 672         if (passthrough)
 673                 booly.bEnabled = OMX_TRUE;
 674         else
 675                 booly.bEnabled = OMX_FALSE;
 676
 677         error = OMX_SetParameter(omx_aud_dec, OMX_IndexParamBrcmDecoderPassThrough,
 678                         &booly);
 679         if (error != OMX_ErrorNone) {
 680                 Log::getInstance()->log("Audio", Log::DEBUG,
 681                                 "Init OMX_IndexParamBrcmDecoderPassThrough failed %x", error);
 682                 DeAllocateCodecsOMX();
 683                 return 0;
 684         }*/
 685         VideoOMX* video=(VideoOMX*)Video::getInstance();
 686         if (disport) {
 687                 video->DisablePort(omx_aud_rend,omx_rend_input_port,false);
 688                 //DestroyInputBufsOMXwhilePlaying();
 689                 //video->CommandFinished(omx_aud_rend,OMX_CommandPortDisable,omx_rend_input_port);
 690
 691         }
 692
 693
 694         OMX_AUDIO_PARAM_PORTFORMATTYPE format;
 695         memset(&format, 0, sizeof(format));
 696         format.nSize = sizeof(format);
 697         format.nVersion.nVersion = OMX_VERSION;
 698         format.nPortIndex = omx_rend_input_port;
 699         error = OMX_GetParameter(omx_aud_rend, OMX_IndexParamAudioPortFormat,
 700                         &format);
 701         if (error != OMX_ErrorNone) {
 702                 Log::getInstance()->log("Audio", Log::DEBUG,
 703                                 "Get OMX_IndexParamAudioPortFormat failed %x %d", error,
 704                                 omx_rend_input_port);
 705                 return 0;
 706         }
 707         if (disport)
 708
 709                 Log::getInstance()->log("Audio", Log::DEBUG,
 710                                 "Get OMX_IndexParamAudioPortFormat returned %d",format.eEncoding );
 711         format.eEncoding = encoding;
 712
 713         error = OMX_SetParameter(omx_aud_rend, OMX_IndexParamAudioPortFormat,
 714                         &format);
 715         if (error != OMX_ErrorNone) {
 716                 Log::getInstance()->log("Audio", Log::DEBUG,
 717                                 "Set OMX_IndexParamAudioPortFormat failed %x %d %d", error,
 718                                 omx_rend_input_port,format.eEncoding );
 719                 //return 0;
 720         }
 721
 722         switch (encoding) {
 723         case OMX_AUDIO_CodingPCM: {
 724                 OMX_AUDIO_PARAM_PCMMODETYPE audio_pcm;
 725                 memset(&audio_pcm, 0, sizeof(audio_pcm));
 726                 audio_pcm.nSize = sizeof(audio_pcm);
 727                 audio_pcm.nVersion.nVersion = OMX_VERSION;
 728                 audio_pcm.nChannels = 2;
 729                 audio_pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
 730                 audio_pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
 731                 //audio_pcm.eChannelMapping[2]=OMX_AUDIO_ChannelMax;
 732                 audio_pcm.eNumData = OMX_NumericalDataSigned;
 733                 audio_pcm.eEndian = OMX_EndianLittle;
 734                 audio_pcm.bInterleaved = OMX_TRUE;
 735                 audio_pcm.nBitPerSample = 16;
 736                 audio_pcm.ePCMMode = OMX_AUDIO_PCMModeLinear;
 737                 audio_pcm.nChannels = 2;
 738                 audio_pcm.nSamplingRate = 48000;
 739                 audio_pcm.nPortIndex = omx_rend_input_port;
 740                 error = OMX_SetParameter(omx_aud_rend, OMX_IndexParamAudioPcm,
 741                                 &audio_pcm);
 742                 if (error != OMX_ErrorNone) {
 743                         Log::getInstance()->log("Audio", Log::DEBUG,
 744                                         "Init OMX_IndexParamAudioPcm failed %x %d", error,
 745                                         omx_rend_input_port);
 746                         return 0;
 747                 }
 748         } break;
 749         case OMX_AUDIO_CodingDDP: {
 750                 OMX_AUDIO_PARAM_DDPTYPE audio_ddp;
 751                 memset(&audio_ddp, 0, sizeof(audio_ddp));
 752                 audio_ddp.nSize = sizeof(audio_ddp);
 753                 audio_ddp.nVersion.nVersion = OMX_VERSION;
 754                 audio_ddp.nPortIndex = omx_rend_input_port;
 755                 audio_ddp.nChannels = 8; //unknown
 756                 audio_ddp.nBitRate=0;
 757                 audio_ddp.nSampleRate=48000;
 758                 audio_ddp.eChannelMapping[0] =OMX_AUDIO_ChannelLF;
 759                 audio_ddp.eChannelMapping[1] =OMX_AUDIO_ChannelRF;
 760                 audio_ddp.eChannelMapping[2] =OMX_AUDIO_ChannelCF;
 761                 audio_ddp.eChannelMapping[3] =OMX_AUDIO_ChannelLFE;
 762                 audio_ddp.eChannelMapping[4] =OMX_AUDIO_ChannelLR;
 763                 audio_ddp.eChannelMapping[5] =OMX_AUDIO_ChannelRR;
 764                 audio_ddp.eChannelMapping[6] =OMX_AUDIO_ChannelLS;
 765                 audio_ddp.eChannelMapping[7] =OMX_AUDIO_ChannelRS;
 766                 audio_ddp.eChannelMapping[8] =OMX_AUDIO_ChannelCS;
 767                 error = OMX_SetParameter(omx_aud_rend, OMX_IndexParamAudioDdp,
 768                                 &audio_ddp);
 769                 if (error != OMX_ErrorNone) {
 770                         Log::getInstance()->log("Audio", Log::DEBUG,
 771                                         "Init OMX_IndexParamAudioDdp failed %x %d", error,
 772                                         omx_rend_input_port);
 773                         return 0;
 774                 }
 775
 776         } break;
 777         default: break; //Make compiler happy
 778         };
 779
 780
 781
 782         if (disport) {
 783
 784                 //PrepareInputBufsOMX(false);
 785                 video->EnablePort(omx_aud_rend,omx_rend_input_port,false);
 786         }
 787
 788
 789
 790         return 1;
 791
 792
 793
 794 }
 795 int AudioOMX::InitDecoderLibAV()
 796 {
 797         libav_mutex.Lock();
 798         ac3codec_context_libav = avcodec_alloc_context3(ac3codec_libav);
 799         if (!ac3codec_context_libav) {
 800                 Log::getInstance()->log("Audio", Log::DEBUG, "Alloc avcodec for ac3 decoding context failed!");
 801                 return 0;
 802         }
 803
 804         ac3codec_context_libav->flags |= CODEC_FLAG_TRUNCATED;
 805         ac3codec_context_libav->request_channels=2;
 806
 807         int avc_ret = avcodec_open2(ac3codec_context_libav, ac3codec_libav, NULL);
 808         if (avc_ret < 0) {
 809                 Log::getInstance()->log("Audio", Log::DEBUG, "Opening libav codec  failed \n");
 810                 libav_mutex.Unlock();
 811                 return 0;
 812         }
 813
 814         aaclatmcodec_context_libav = avcodec_alloc_context3(aaclatmcodec_libav);
 815         if (!aaclatmcodec_context_libav) {
 816                 Log::getInstance()->log("Audio", Log::DEBUG, "Alloc avcodec for aac decoding context failed!");
 817                 return 0;
 818         }
 819
 820         aaclatmcodec_context_libav->flags |= CODEC_FLAG_TRUNCATED;
 821         aaclatmcodec_context_libav->request_channels=2;
 822
 823         avc_ret = avcodec_open2(aaclatmcodec_context_libav, aaclatmcodec_libav, NULL);
 824         if (avc_ret < 0) {
 825                 Log::getInstance()->log("Audio", Log::DEBUG, "Opening libav codec  failed \n");
 826                 libav_mutex.Unlock();
 827                 return 0;
 828         }
 829
 830
 831         mp23codec_context_libav = avcodec_alloc_context3(mp23codec_libav);
 832         if (!ac3codec_context_libav) {
 833                 Log::getInstance()->log("Audio", Log::DEBUG, "Alloc avcodec for mp23 decoding context failed!");
 834                 libav_mutex.Unlock();
 835                 return 0;
 836         }
 837
 838         mp23codec_context_libav->flags |= CODEC_FLAG_TRUNCATED;
 839         mp23codec_context_libav->request_channels=2;
 840
 841         avc_ret = avcodec_open2(mp23codec_context_libav, mp23codec_libav, NULL);
 842         if (avc_ret < 0) {
 843                 Log::getInstance()->log("Audio", Log::DEBUG, "Opening libav codec  failed \n");
 844                 libav_mutex.Unlock();
 845                 return 0;
 846         }
 847 #ifdef USE_LIBRESAMPLE
 848         resam_con_libav = avresample_alloc_context();
 849         if (resam_con_libav == NULL) {
 850                 Log::getInstance()->log("Audio", Log::DEBUG,
 851                                 "Alloc resample context failed");
 852                 return 0;
 853         }
 854
 855         av_opt_set_int(resam_con_libav, "out_channel_layout", AV_CH_LAYOUT_STEREO,  0); // our standard format
 856         av_opt_set_int(resam_con_libav, "out_sample_rate",48000,0);
 857         av_opt_set_int(resam_con_libav, "out_sample_fmt",AV_SAMPLE_FMT_S16,0);
 858
 859         av_opt_set_int(resam_con_libav, "in_sample_rate",48000,0);
 860         av_opt_set_int(resam_con_libav, "in_sample_fmt",AV_SAMPLE_FMT_S16,0);
 861         av_opt_set_int(resam_con_libav, "in_channel_layout",  AV_CH_LAYOUT_5POINT1, 0); //just an example
 862 #endif
 863
 864          av_init_packet(&incoming_paket_libav);
 865          decode_frame_libav=avcodec_alloc_frame();
 866          libav_mutex.Unlock();
 867          decompress_buffer_filled=0;
 868
 869
 870
 871         return 1;
 872 }
 873
 874 void AudioOMX::DeinitDecoderLibAV() {
 875
 876
 877         libav_mutex.Lock();
 878         if (ac3codec_context_libav) {
 879                 avcodec_close(ac3codec_context_libav);
 880                 av_free(ac3codec_context_libav);
 881                 ac3codec_context_libav = NULL;
 882
 883                 avcodec_close(aaclatmcodec_context_libav);
 884                 av_free(aaclatmcodec_context_libav);
 885                 aaclatmcodec_context_libav = NULL;
 886
 887                 av_free(decode_frame_libav);
 888
 889                 avcodec_close(mp23codec_context_libav);
 890                 av_free(mp23codec_context_libav);
 891                 mp23codec_context_libav = NULL;
 892 #ifdef USE_LIBRESAMPLE
 893                 avresample_free(resam_con_libav);
 894                 resam_con_libav=NULL;
 895 #endif
 896
 897         }
 898         libav_mutex.Unlock();
 899
 900 }
 901
 902
 903 int AudioOMX::AllocateCodecsOMX()
 904 {
 905         OMX_ERRORTYPE error;
 906         static OMX_CALLBACKTYPE callbacks= {&VideoOMX::EventHandler_OMX,&EmptyBufferDone_OMX,&FillBufferDone_OMX};
 907
 908         Log::getInstance()->log("Audio", Log::NOTICE, "Allocate Codecs OMX");
 909         //Clock, move later to audio
 910         VideoOMX *video=(VideoOMX*)Video::getInstance();
 911
 912         if (!InitDecoderLibAV()) return 0;;
 913
 914
 915         OMX_PORT_PARAM_TYPE p_param;
 916         memset(&p_param,0,sizeof(p_param));
 917         p_param.nSize=sizeof(p_param);
 918         p_param.nVersion.nVersion=OMX_VERSION;
 919
 920
 921         if (!video->getClockAudioandInit(&omx_clock,&omx_clock_output_port)){
 922                 return 0;// get the clock and init it if necessary
 923         }
 924
 925         /* TODO end */
 926         if (!video->idleClock()) {
 927                 return 0;
 928         }
 929         video->LockClock();
 930
 931         error = OMX_GetHandle(&omx_aud_rend, VPE_OMX_AUDIO_REND, NULL, &callbacks);
 932         if (error != OMX_ErrorNone) {
 933                 Log::getInstance()->log("Audio", Log::DEBUG,
 934                                 "Init OMX audio rend failed %x", error);
 935                 video->UnlockClock();
 936                 DeAllocateCodecsOMX();
 937                 return 0;
 938         }
 939
 940         if (!ChangeAudioDestination()) {
 941                 video->UnlockClock();
 942                 DeAllocateCodecsOMX();
 943                 return 0;
 944         }
 945
 946         error = OMX_GetParameter(omx_aud_rend, OMX_IndexParamAudioInit, &p_param);
 947         if (error != OMX_ErrorNone) {
 948                 Log::getInstance()->log("Audio", Log::DEBUG,
 949                                 "Init OMX audio rend OMX_GetParameter failed %x", error);
 950                 video->UnlockClock();
 951                 DeAllocateCodecsOMX();
 952                 return 0;
 953         }
 954         omx_rend_input_port = p_param.nStartPortNumber;
 955
 956
 957
 958
 959
 960         error = OMX_GetParameter(omx_aud_rend, OMX_IndexParamOtherInit, &p_param);
 961         if (error != OMX_ErrorNone) {
 962                 Log::getInstance()->log("Audio", Log::DEBUG,
 963                                 "Init OMX aud rend OMX_GetParameter failed %x", error);
 964                 video->UnlockClock();
 965                 DeAllocateCodecsOMX();
 966                 return 0;
 967         }
 968         // buggy return value
 969         omx_rend_clock_port = p_param.nStartPortNumber;
 970
 971
 972
 973
 974 /*      error=OMX_GetHandle(&omx_aud_dec,VPE_OMX_AUDIO_DECODER,NULL,&callbacks);
 975
 976         if (error!=OMX_ErrorNone){
 977                 Log::getInstance()->log("Audio", Log::DEBUG, "Init OMX audio decoder failed %x", error);
 978                 video->UnlockClock();
 979                 DeAllocateCodecsOMX();
 980                 return 0;
 981         }
 982
 983         error=OMX_GetParameter(omx_aud_dec,OMX_IndexParamAudioInit,&p_param);
 984         if (error!=OMX_ErrorNone){
 985                 Log::getInstance()->log("Audio", Log::DEBUG, "Init OMX audio decoder OMX_GetParameter failed %x", error);
 986                 video->UnlockClock();
 987                 DeAllocateCodecsOMX();
 988             return 0;
 989         }
 990         omx_codec_input_port=p_param.nStartPortNumber;
 991         omx_codec_output_port=p_param.nStartPortNumber+1;
 992
 993         if (!video->DisablePort(omx_aud_dec,omx_codec_input_port) || !video->DisablePort(omx_aud_dec,omx_codec_output_port)) {
 994                 Log::getInstance()->log("Audio", Log::DEBUG, "Disable Ports OMX audio decoder failed");
 995                 video->UnlockClock();
 996                 DeAllocateCodecsOMX();
 997                 return 0;
 998         }*/
 999
1000
1001
1002
1003         if (!video->DisablePort(omx_aud_rend,omx_rend_input_port,true) ) {
1004                 Log::getInstance()->log("Audio", Log::DEBUG, "Disable Ports OMX audio rend failed %d",omx_rend_input_port);
1005                 video->UnlockClock();
1006                 DeAllocateCodecsOMX();
1007                 return 0;
1008         }
1009
1010         if ( !video->DisablePort(omx_aud_rend, omx_rend_clock_port, true)) {
1011                 Log::getInstance()->log("Audio", Log::DEBUG,
1012                                 "Disable Ports OMX rend clock port failed %d",omx_rend_clock_port);
1013                 video->UnlockClock();
1014                 DeAllocateCodecsOMX();
1015                 return 0;
1016         }
1017
1018
1019
1020
1021         //Setuo chain
1022
1023
1024         error=OMX_SetupTunnel(omx_clock,omx_clock_output_port,omx_aud_rend,omx_rend_clock_port);
1025         if (error!=OMX_ErrorNone){
1026                 Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Setup tunnel clock to rend failed %x %d %d", error,omx_clock_output_port,omx_rend_clock_port);
1027                 video->UnlockClock();
1028                 DeAllocateCodecsOMX();
1029                 return 0;
1030         }
1031
1032         if (!video->EnablePort(omx_clock,omx_clock_output_port,false) || !video->EnablePort(omx_aud_rend,omx_rend_clock_port,false)
1033                                         ) {
1034                 Log::getInstance()->log("Audio", Log::DEBUG, "Enable Ports OMX clock rend failed");
1035                 video->UnlockClock();
1036                 DeAllocateCodecsOMX();
1037                 return 0;
1038         }
1039
1040         if (!video->ChangeComponentState(omx_aud_rend,OMX_StateIdle)) {
1041                 Log::getInstance()->log("Audio", Log::DEBUG, "aud_rend idle ChangeComponentState");
1042                 video->UnlockClock();
1043                 DeAllocateCodecsOMX();
1044                 return 0;
1045         }
1046
1047
1048
1049
1050         if ( !video->CommandFinished(omx_aud_rend,OMX_CommandPortEnable,omx_rend_clock_port)) {
1051                 video->UnlockClock();
1052                 DeAllocateCodecsOMX();
1053                 return 0;
1054         }
1055
1056         if ( !video->CommandFinished(omx_clock,OMX_CommandPortEnable,omx_clock_output_port)) {
1057                 video->UnlockClock();
1058                 DeAllocateCodecsOMX();
1059                 return 0;
1060         }
1061
1062
1063
1064         if (!ChangeAudioPortConfig(false)){
1065                     Log::getInstance()->log("Audio", Log::NOTICE, "Change AudioPortConfig failed");
1066                     video->UnlockClock();
1067                     DeAllocateCodecsOMX();
1068                         return 0;
1069         }
1070
1071 /*      if (!video->ChangeComponentState(omx_aud_dec,OMX_StateIdle)) {
1072                 Log::getInstance()->log("Audio", Log::DEBUG, "aud_dec ChangeComponentState");
1073                 DeAllocateCodecsOMX();
1074                 return 0;
1075         }*/
1076
1077
1078
1079         if (!PrepareInputBufsOMX(true)) {
1080                 video->UnlockClock();
1081                 DeAllocateCodecsOMX();
1082                 return 0;
1083         }
1084
1085
1086
1087 /*      error=OMX_SetupTunnel(omx_aud_dec,omx_codec_output_port,omx_aud_rend,omx_rend_input_port);
1088         if (error!=OMX_ErrorNone){
1089                 Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Setup tunnel dec to render failed %x", error);
1090                  video->UnlockClock();
1091                 DeAllocateCodecsOMX();
1092                 return 0;
1093         }*/
1094
1095
1096
1097 /*      if (!video->EnablePort(omx_aud_dec,omx_codec_output_port,false) || !video->EnablePort(omx_aud_rend,omx_rend_input_port,false)
1098                                                 ) {
1099                 Log::getInstance()->log("Audio", Log::DEBUG, "Enable Ports OMX codec rend failed");
1100                  video->UnlockClock();
1101                 DeAllocateCodecsOMX();
1102                 return 0;
1103         }*/
1104
1105 /*      if ( !video->CommandFinished(omx_aud_dec,OMX_CommandPortEnable,omx_codec_output_port)
1106                         || !video->CommandFinished(omx_aud_rend,OMX_CommandPortEnable,omx_rend_input_port)) {
1107                          video->UnlockClock();
1108                 DeAllocateCodecsOMX();
1109                 return 0;
1110         }*/
1111
1112         if (!video->ChangeComponentState(omx_aud_rend,OMX_StateExecuting)) {
1113                 Log::getInstance()->log("Audio", Log::DEBUG, "omx_aud_rend ChangeComponentState Execute");
1114                  video->UnlockClock();
1115                 DeAllocateCodecsOMX();
1116                 return 0;
1117         }
1118
1119
1120         video->UnlockClock();
1121         omx_running=true;
1122         setVolume(volume);
1123         doMuting();
1124         video->clockUnpause();
1125
1126
1127         if (!video->setClockExecutingandRunning()) return 0;
1128
1129         Log::getInstance()->log("Audio", Log::NOTICE, "Allocate Codecs OMX finished");
1130
1131         return 1;
1132 }
1133
1134
1135
1136
1137 int AudioOMX::PrepareInputBufsOMX(bool setportdef) //needs to be called with locvke omx clock mutex
1138 {
1139         VideoOMX *video=(VideoOMX*)Video::getInstance();
1140         OMX_ERRORTYPE error;
1141         OMX_PARAM_PORTDEFINITIONTYPE port_def_type;
1142         memset(&port_def_type,0,sizeof(port_def_type));
1143         port_def_type.nSize=sizeof(port_def_type);
1144         port_def_type.nVersion.nVersion=OMX_VERSION;
1145         port_def_type.nPortIndex=omx_rend_input_port;//omx_codec_input_port;
1146
1147         error=OMX_GetParameter(omx_aud_rend/*dec*/,OMX_IndexParamPortDefinition, &port_def_type);
1148
1149         if (error!=OMX_ErrorNone){
1150                         Log::getInstance()->log("Audio", Log::DEBUG, "Get OMX OMX_IndexParamPortDefinition failed %x", error);
1151         }
1152
1153
1154         if (setportdef) {
1155                 port_def_type.nBufferCountActual=2;
1156                 port_def_type.nBufferSize=max(port_def_type.nBufferSize,50000); // for transcoder important
1157
1158                 error=OMX_SetParameter(omx_aud_rend/*dec*/,OMX_IndexParamPortDefinition, &port_def_type);
1159
1160                 if (error!=OMX_ErrorNone){
1161                         Log::getInstance()->log("Audio", Log::DEBUG, "Set OMX OMX_IndexParamPortDefinition failed %x", error);
1162                 }
1163         }
1164
1165
1166         error=OMX_SendCommand(omx_aud_rend/*dec*/,OMX_CommandPortEnable,omx_rend_input_port/*codec*/,0);
1167         if (error!=OMX_ErrorNone){
1168                 Log::getInstance()->log("Audio", Log::DEBUG, "Prepare Input bufs Send Command to enable port %x", error);
1169                 return 0;
1170         }
1171
1172         input_bufs_omx_mutex.Lock();
1173         for (unsigned int i=0; i< port_def_type.nBufferCountActual;i++) {
1174                 OMX_BUFFERHEADERTYPE *buf_head=NULL;
1175                 error=OMX_AllocateBuffer(omx_aud_rend/*dec*/,&buf_head,omx_rend_input_port/*codec*/,NULL,port_def_type.nBufferSize);
1176                 if (error!=OMX_ErrorNone){
1177                         Log::getInstance()->log("Audio", Log::DEBUG, "Use OMX_AllocateBuffer failed %x", error);
1178                                 input_bufs_omx_mutex.Unlock();
1179                         return 0;
1180                 }
1181                 input_bufs_omx_all.push_back(buf_head);
1182                 input_bufs_omx_free.push_back(buf_head);
1183         }
1184         omx_first_frame=true;
1185
1186         firstsynched=false;
1187         cur_input_buf_omx=NULL;
1188         input_bufs_omx_mutex.Unlock();
1189
1190         if (!video->CommandFinished(omx_aud_rend/*dec*/,OMX_CommandPortEnable,omx_rend_input_port /*codec*/)) {
1191                 return 0;
1192         }
1193
1194         return 1;
1195 }
1196
1197 int AudioOMX::DestroyInputBufsOMX() //call with clock mutex locked
1198 {
1199         OMX_ERRORTYPE error;
1200
1201         cur_input_buf_omx=NULL;
1202         input_bufs_omx_mutex.Lock();
1203         for (int i=0; i< input_bufs_omx_all.size();i++) {
1204                 error=OMX_FreeBuffer(omx_aud_rend/*dec*/,omx_rend_input_port/*codec*/,input_bufs_omx_all[i]);
1205                 if (error!=OMX_ErrorNone){
1206                         Log::getInstance()->log("Audio", Log::DEBUG, "Use OMX_FreeBuffer failed %x", error);
1207                         input_bufs_omx_mutex.Unlock();
1208                         return 0;
1209                 }
1210
1211         }
1212         input_bufs_omx_all.clear();
1213         input_bufs_omx_free.clear();
1214         input_bufs_omx_mutex.Unlock();
1215
1216 }
1217
1218 int AudioOMX::DestroyInputBufsOMXwhilePlaying() //call with clock mutex locked
1219 {
1220         OMX_ERRORTYPE error;
1221
1222         cur_input_buf_omx=NULL;
1223         input_bufs_omx_mutex.Lock();
1224         while (input_bufs_omx_all.size()>0) {
1225                 if (input_bufs_omx_free.size()>0) {
1226                         // Destroy one buffer
1227                         vector<OMX_BUFFERHEADERTYPE*>::iterator itty=input_bufs_omx_all.begin();
1228                         OMX_BUFFERHEADERTYPE* cur_buf=input_bufs_omx_free.front();
1229                         for (; itty!= input_bufs_omx_all.end();itty++) {
1230                                 if ((*itty)==cur_buf) {
1231                                         input_bufs_omx_all.erase(itty);
1232                                         input_bufs_omx_free.pop_front();
1233                                         break;
1234                                 }
1235                         }
1236                 } else {
1237                         input_bufs_omx_mutex.Unlock();
1238                         MILLISLEEP(5);
1239                         input_bufs_omx_mutex.Lock();
1240                 }
1241         }
1242
1243         Log::getInstance()->log("Audio", Log::DEBUG, "DestroyInputBufsOMXwhilePlaying %d %d", input_bufs_omx_all.size(),input_bufs_omx_free.size());
1244         input_bufs_omx_mutex.Unlock();
1245         return 1;
1246 }
1247
1248
1249 int AudioOMX::DeAllocateCodecsOMX()
1250 {
1251         OMX_ERRORTYPE error;
1252         omx_running=false;
1253         VideoOMX *video=(VideoOMX*)Video::getInstance();
1254          Log::getInstance()->log("Audio", Log::DEBUG, "enter deallocatecodecsomx");
1255
1256
1257
1258    Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 1");
1259    if (cur_input_buf_omx) {
1260                 cur_input_buf_omx->nFlags|=OMX_BUFFERFLAG_EOS;
1261                 OMX_ERRORTYPE error=video->ProtOMXEmptyThisBuffer(omx_aud_rend/*dec*/,cur_input_buf_omx);
1262                 if (error!=OMX_ErrorNone) {
1263                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_EmptyThisBuffer 6 failed %x", error);
1264                 }
1265
1266                 cur_input_buf_omx=NULL;//write out old data
1267         }
1268    Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 2");
1269
1270    video->LockClock();
1271         if (omx_aud_rend/*dec*/) {
1272                 // first stop the omx elements
1273         /*      if (!video->ChangeComponentState(omx_aud_dec,OMX_StateIdle)) {
1274                         Log::getInstance()->log("Audio", Log::DEBUG, "aud_dec ChangeComponentState");
1275                 }*/
1276                  Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 3");
1277
1278                 video->UnlockClock();
1279                 Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 4");
1280                 video->idleClock();
1281                 Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 5");
1282                  video->LockClock();
1283
1284                 if (!video->ChangeComponentState(omx_aud_rend,OMX_StateIdle)) {
1285                         Log::getInstance()->log("Audio", Log::DEBUG, "aud_rend ChangeComponentState");
1286                 }
1287
1288         // TODO proper deinit sequence
1289                 // first flush all buffers
1290
1291                 error=OMX_SendCommand(omx_aud_rend,OMX_CommandFlush, omx_rend_input_port, NULL);
1292                 if (error!=OMX_ErrorNone) {
1293                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Flush rend in failed %x", error);
1294
1295                 }
1296
1297         /*      error=OMX_SendCommand(omx_aud_dec,OMX_CommandFlush, omx_codec_input_port, NULL);
1298                 if (error!=OMX_ErrorNone){
1299                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Flush codec out failed %x", error);
1300
1301                 }*/
1302
1303
1304         /*      if (!video->CommandFinished(omx_aud_dec,OMX_CommandFlush,omx_codec_input_port)) {
1305                         Log::getInstance()->log("Audio", Log::DEBUG, "flush cmd codec input failed");
1306                 }*/
1307
1308
1309
1310                 error=OMX_SendCommand(omx_clock,OMX_CommandFlush, omx_clock_output_port, NULL);
1311                 if (error!=OMX_ErrorNone){
1312                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Flush clock out failed %x", error);
1313
1314                 }
1315
1316                 error=OMX_SendCommand(omx_aud_rend,OMX_CommandFlush, omx_rend_clock_port, NULL);
1317                 if (error!=OMX_ErrorNone){
1318                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Flush rend clock failed %x", error);
1319
1320                 }
1321                 Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 6");
1322
1323                 if (!video->CommandFinished(omx_clock,OMX_CommandFlush,omx_clock_output_port) ||
1324                         !video->CommandFinished(omx_aud_rend,OMX_CommandFlush,omx_rend_clock_port)) {
1325                                 Log::getInstance()->log("Audio", Log::DEBUG, "flush cmd clock shed failed");
1326                 }
1327
1328                 DestroyInputBufsOMX(); //We have to make sure that no buffers are in use
1329                 Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 6a");
1330                 DeinitDecoderLibAV();
1331                 Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 7");
1332
1333                 //todo flushing
1334                 if (!video->DisablePort(omx_aud_rend,omx_rend_input_port,true)) {
1335                         Log::getInstance()->log("Audio", Log::DEBUG, "Disable Tunnel Port failed 1");
1336                 }
1337
1338         /*      if (!video->DisablePort(omx_aud_dec,omx_codec_output_port,true)) {
1339                         Log::getInstance()->log("Audio", Log::DEBUG, "Disable Tunnel Port failed 6");
1340                 }
1341
1342                 if (!video->DisablePort(omx_aud_dec,omx_codec_input_port,true)) {
1343                         Log::getInstance()->log("Audio", Log::DEBUG, "Disable Tunnel Port failed 7");
1344                 }*/
1345
1346
1347                 if (!video->DisablePort(omx_aud_rend,omx_rend_clock_port,true)) {
1348                         Log::getInstance()->log("Audio", Log::DEBUG, "Disable Tunnel Port failed 4");
1349                 }
1350
1351                 if (!video->DisablePort(omx_clock,omx_clock_output_port,true)) {
1352                         Log::getInstance()->log("Audio", Log::DEBUG, "Disable Tunnel Port failed 5");
1353                 }
1354
1355
1356
1357         /*      error=OMX_SetupTunnel(omx_aud_dec,omx_codec_output_port,NULL,NULL);
1358                 if (error!=OMX_ErrorNone) {
1359                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Setup tunnel teardown failed %x", error);
1360
1361                 }*/
1362
1363
1364
1365                 error=OMX_SetupTunnel(omx_aud_rend,omx_rend_input_port,NULL,NULL);
1366                 if (error!=OMX_ErrorNone) {
1367                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Setup tunnel teardown failed %x", error);
1368
1369                 }
1370
1371                 error=OMX_SetupTunnel(omx_clock,omx_clock_output_port,NULL,NULL);
1372                 if (error!=OMX_ErrorNone) {
1373                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Setup tunnel teardown failed %x", error);
1374
1375                 }
1376
1377                 error=OMX_SetupTunnel(omx_aud_rend,omx_rend_clock_port,NULL,NULL);
1378                 if (error!=OMX_ErrorNone) {
1379                         Log::getInstance()->log("Audio", Log::DEBUG, "OMX_Setup tunnel teardown failed %x", error);
1380
1381                 }
1382                 Log::getInstance()->log("Audio", Log::DEBUG, "deallocatecodecsomx mark 8");
1383
1384
1385                 //error=OMX_FreeHandle(omx_aud_dec);
1386                 error=OMX_FreeHandle(omx_aud_rend);
1387                 video->UnlockClock();
1388                 video->destroyClock();
1389                 omx_aud_rend/*dec*/=NULL;
1390                 if (error!=OMX_ErrorNone) {
1391                         Log::getInstance()->log("Audio", Log::DEBUG, "FreeHandle failed %d", error);
1392                 }
1393         } else  {
1394
1395                 video->UnlockClock();
1396                 DeinitDecoderLibAV();
1397         }
1398           Log::getInstance()->log("Audio", Log::DEBUG, "leave deallocate codecs OMX");
1399
1400         return 1;
1401 }
1402
1403
1404
1405 int AudioOMX::stop()
1406 {
1407   if (!initted) return 0;
1408
1409   Log::getInstance()->log("Audio", Log::DEBUG, "Audio stop called");
1410   DeAllocateCodecsOMX();
1411   //if (ioctl(fdAudio, AV_SET_AUD_RESET, 0x11) != 0) return 0;
1412   return 1;
1413 }
1414
1415 int AudioOMX::mute() {
1416         if (!initted)
1417                 return 0;
1418         Log::getInstance()->log("Audio", Log::DEBUG, "MUTE MUTE MUTE");
1419         VideoOMX *vw = (VideoOMX*) Video::getInstance();
1420     vw->LockClock();
1421         if (omx_running) {
1422
1423                 OMX_AUDIO_CONFIG_MUTETYPE amute;
1424                 memset(&amute, 0, sizeof(amute));
1425                 amute.nSize = sizeof(amute);
1426                 amute.nVersion.nVersion = OMX_VERSION;
1427                 amute.nPortIndex = omx_rend_input_port;
1428                 amute.bMute = OMX_TRUE;
1429                 OMX_ERRORTYPE error= OMX_SetParameter(omx_aud_rend, OMX_IndexConfigAudioMute,
1430                                                 &amute);
1431                 if (error != OMX_ErrorNone) {
1432                         Log::getInstance()->log("Audio", Log::DEBUG,
1433                                         "Set OMX_IndexConfigAudioMute failed %x %d", error,
1434                                         omx_rend_input_port);
1435                         vw->UnlockClock();
1436                         return 0;
1437                 }
1438
1439         }
1440         vw->UnlockClock();
1441
1442         muted = 1;
1443         return 1;
1444 }
1445
1446 int AudioOMX::unMute()
1447 {
1448   if (!initted) return 0;
1449
1450   Log::getInstance()->log("Audio", Log::DEBUG, "MUTE OFF OFF OFF");
1451   VideoOMX *vw = (VideoOMX*) Video::getInstance();
1452   vw->LockClock();
1453   if (omx_running) {
1454
1455                 OMX_AUDIO_CONFIG_MUTETYPE amute;
1456                 memset(&amute, 0, sizeof(amute));
1457                 amute.nSize = sizeof(amute);
1458                 amute.nVersion.nVersion = OMX_VERSION;
1459                 amute.nPortIndex = omx_rend_input_port;
1460                 amute.bMute = OMX_FALSE;
1461                 OMX_ERRORTYPE error = OMX_SetParameter(omx_aud_rend, OMX_IndexConfigAudioMute,
1462                                                 &amute);
1463                 if (error != OMX_ErrorNone) {
1464                         Log::getInstance()->log("Audio", Log::DEBUG,
1465                                         "Set OMX_IndexConfigAudioMute failed %x %d", error,
1466                                         omx_rend_input_port);
1467                         vw->UnlockClock();
1468                         return 0;
1469                 }
1470         }
1471
1472         vw->UnlockClock();
1473
1474   muted = 0;
1475   return 1;
1476 }
1477
1478 int AudioOMX::pause() {
1479         if (!initted)
1480                 return 0;
1481
1482         VideoOMX *vw = (VideoOMX*) Video::getInstance();
1483         vw->clockPause();
1484
1485         return 1;
1486 }
1487
1488 int AudioOMX::unPause()
1489 {
1490   if (!initted) return 0;
1491
1492   VideoOMX *vw = (VideoOMX*) Video::getInstance();
1493
1494   vw->clockUnpause();
1495
1496   return 1;
1497 }
1498
1499 int AudioOMX::reset()
1500 {
1501   if (!initted) return 0;
1502 //test();
1503   Log::getInstance()->log("Audio", Log::DEBUG, "reset called");
1504   DeAllocateCodecsOMX();
1505
1506 //  if (ioctl(fdAudio, AV_SET_AUD_RESET, 0x11) != 0) return 0;
1507 //  Log::getInstance()->log("Audio", Log::DEBUG, "reset back");
1508  // if (ioctl(fdAudio, AV_SET_AUD_PLAY, 0) != 0) return 0;
1509
1510   doMuting();
1511   return 1;
1512 }
1513
1514 int AudioOMX::setVolume(int tvolume)
1515 {
1516   // parameter: 0 for silence, 20 for full
1517   if ((tvolume < 0) || (tvolume > 20)) return 0;
1518
1519 // volume = 2 * (20 - volume);
1520 // Right, that one was rubbish... 0-10 were almost
1521 // inaudible, 11-20 did what should have been done
1522 // over the whole 0-20 range
1523   volume=tvolume;
1524
1525
1526   VideoOMX *vw = (VideoOMX*) Video::getInstance();
1527   vw->LockClock();
1528   if (omx_running) {
1529
1530           OMX_AUDIO_CONFIG_VOLUMETYPE avol;
1531           memset(&avol, 0, sizeof(avol));
1532           avol.nSize = sizeof(avol);
1533           avol.nVersion.nVersion = OMX_VERSION;
1534           avol.nPortIndex = omx_rend_input_port;
1535           avol.bLinear=OMX_FALSE;
1536           avol.sVolume.nValue =(volume-20)*200;
1537           OMX_ERRORTYPE error = OMX_SetParameter(omx_aud_rend, OMX_IndexConfigAudioVolume,
1538                           &avol);
1539           if (error != OMX_ErrorNone) {
1540                   Log::getInstance()->log("Audio", Log::DEBUG,
1541                                   "Set OMX_IndexConfigAudioVolume failed %x %d", error,
1542                                   omx_rend_input_port);
1543                   vw->UnlockClock();
1544                   return 0;
1545           }
1546
1547   }
1548   vw->UnlockClock();
1549
1550   return 1;
1551 }
1552
1553 #ifdef DEV
1554 int AudioOMX::test()
1555 {
1556 //  ULLONG stc = 0;
1557 //  return ioctl(fdAudio, AV_SET_AUD_STC, &stc);
1558
1559 /*  aud_sync_parms_t a;
1560   a.parm1 = 0;
1561   a.parm2 = 0;
1562 */
1563 //  int b = ioctl(fdAudio, AV_SET_AUD_DISABLE_SYNC, &a);
1564
1565
1566   /*OK*/ //printf("Audio sync disable = %i\n", b);
1567
1568   return 1;
1569
1570
1571 }
1572 #endif
1573
1574 unsigned int AudioOMX::AdvanceMpAudioSync(const UCHAR *data,unsigned int size,unsigned int *framesize)
1575 {
1576         if (size<=2) return size; // silly;
1577         unsigned int test=0;
1578         *framesize=0;
1579         //inspired by libav parsing code
1580         while (test+1<size) {
1581                 if (data[test]==0xFF && (data[test+1] &0xe0)==0xe0) {
1582                         const int sample_rates[4]={44100,48000,32000,0};
1583                         const short bitrate_tab[2][3][15] = { { { 0, 32, 64, 96, 128, 160,
1584                                         192, 224, 256, 288, 320, 352, 384, 416, 448 }, { 0, 32, 48,
1585                                         56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 }, {
1586                                         0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224,
1587                                         256, 320 } }, { { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144,
1588                                         160, 176, 192, 224, 256 }, { 0, 8, 16, 24, 32, 40, 48, 56,
1589                                         64, 80, 96, 112, 128, 144, 160 }, { 0, 8, 16, 24, 32, 40,
1590                                         48, 56, 64, 80, 96, 112, 128, 144, 160 } } };
1591                         int lsf=0;
1592                         int mpeg2=0;
1593                         int layer=4-((data[test+1]&0x06)>>1);
1594                         if (layer==4) {test++;continue;} //sanity check
1595
1596                         int bitrate_index=(data[test+2]&0xf0)>>4;
1597                         if (bitrate_index==0x0f || bitrate_index==0x0) {test++;continue;} //sanity check
1598
1599                         int samplerate_index=(data[test+2]&0x0C)>>2;
1600                         if (samplerate_index==0x03) {test++;continue;} //sanity check
1601
1602                         int padding=(data[test+2]&2)>>1;
1603                         if (0x10 &  data[test+1]) {
1604                                 lsf=((data[test+1]) &0x8)?0:1;
1605                                 mpeg2=0;
1606                         } else {
1607                                 lsf=1;
1608                                 mpeg2=1;
1609                         }
1610                         int sample_rate=sample_rates[ samplerate_index]>>(lsf+mpeg2);
1611                         int frame_size=0;
1612                         int temp_frame_size=bitrate_tab[lsf][layer - 1][bitrate_index];
1613                         if (layer==1) {
1614                                 frame_size=(temp_frame_size*12000)/sample_rate;
1615                                 frame_size=(frame_size+padding)*4;
1616                         } else if (layer==2) {
1617                                 frame_size=(temp_frame_size*144000)/sample_rate;
1618                             frame_size=frame_size+padding;
1619                         } else {
1620                                 frame_size=(temp_frame_size*144000)/(sample_rate<<lsf);
1621                                 frame_size=frame_size+padding;
1622                         }
1623                         //Log::getInstance()->log("Audio", Log::DEBUG, "FRAME: %d %d %d %d %d %d %d",lsf,layer,bitrate_index,sample_rate,padding,temp_frame_size, frame_size);
1624                         //Log::getInstance()->log("Audio", Log::DEBUG, "FRAME DIAG: %x %x %x ",data[test],data[test+1],data[test+2]);
1625                         *framesize=frame_size;
1626
1627                         return test; // probably FrameSync
1628                 }
1629                 test++;
1630         }
1631         return size;
1632 }
1633
1634 unsigned int AudioOMX::AdvanceAc3AudioSync(const UCHAR *data,unsigned int size,unsigned int *framesize)
1635 {
1636         if (size<=4) return size; // silly;
1637         const int frm_size_tab[] = { 64, 64, 80, 80, 96, 96, 112, 112, 128, 128,
1638                         160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384, 384, 448,
1639                         448, 512, 512, 640, 640, 768, 768, 896, 896, 1024, 1024, 1152,
1640                         1152, 1280, 1280, };
1641         unsigned int test=0;
1642         *framesize=20000; //if we do not find a start code do not decompress
1643         while (test+4<size) {
1644                 if (data[test]==0x0B && data[test+1]==0x77) {
1645                         // now figure out the length of the frame
1646                         unsigned char code=data[test+4];
1647                         unsigned char fscod=(code& 0xC0)>>6;
1648                         unsigned char frmsize=(code &0x3f);
1649                         if (fscod!=0) Log::getInstance()->log("Audio", Log::DEBUG, "warning we only support 48 KHz sampling rate");
1650                         *framesize=frm_size_tab[frmsize]*2;
1651                         return test; // probably FrameSync
1652                 }
1653                 test++;
1654         }
1655         return size;
1656 }
1657
1658 unsigned int AudioOMX::AdvanceAacLatmAudioSync(const UCHAR *data,unsigned int size,unsigned int *framesize)
1659 {
1660         if (size<=4) return size; // silly;
1661         unsigned int test=0;
1662         *framesize=20000; //if we do not find a start code do not decompress
1663         while (test+4<size) {
1664                 if (data[test] ==0x56 && (data[test+1]& 0xe0)==0xe0) {
1665                         // now figure out the length of the frame
1666                         unsigned int length= ((0x1f & data[test+1])<<8) | data[test+2];
1667                         *framesize=length+3;
1668                         return test; // probably FrameSync
1669                 }
1670                 test++;
1671         }
1672         return size;
1673 }
1674 #ifndef USE_LIBRESAMPLE
1675 #define SQRT3_2      1.22474487139158904909
1676
1677 void AudioOMX::getDownMixMatrix(unsigned long long channels,
1678                 int *left_mat,int *right_mat)
1679 {
1680         int i,j;
1681         double downmix_matrix[2][64];
1682         for (i=0;i<64;i++) {
1683                 for (j=0;j<2;j++) {
1684                         downmix_matrix[j][i]=0.;
1685                 }
1686         }
1687         downmix_matrix[0/*links*/][/*FRONT_LEFT*/0]=1.;
1688         downmix_matrix[1/*rechts*/][/*FRONT_RIGHT*/1]=1.;
1689         downmix_matrix[0/*links*/]  [/*FRONT_CENTER*/2] = M_SQRT1_2;
1690         downmix_matrix[1/*rechts*/] [/*FRONT_CENTER*/2] = M_SQRT1_2;
1691
1692         if (channels & (AV_CH_BACK_LEFT | AV_CH_SIDE_LEFT) ) {
1693                 downmix_matrix[0/*links*/][/*BACK_CENTER*/8]=-M_SQRT1_2*M_SQRT1_2;
1694                 downmix_matrix[1/*rechts*/][/*BACK_CENTER*/8]=M_SQRT1_2*M_SQRT1_2;
1695         } else {
1696                 downmix_matrix[0/*links*/][/*BACK_CENTER*/8]=-M_SQRT1_2;
1697                 downmix_matrix[1/*rechts*/][/*BACK_CENTER*/8]=M_SQRT1_2;
1698         }
1699         downmix_matrix[0/*links*/][/*BACK_LEFT*/4 ]=-M_SQRT1_2*SQRT3_2;
1700     downmix_matrix[1/*rechts*/][/*BACK_LEFT*/4]=M_SQRT1_2*M_SQRT1_2;
1701     downmix_matrix[0/*links*/][/*BACK_RIGHT*/5 ]=-M_SQRT1_2*M_SQRT1_2;
1702     downmix_matrix[1/*rechts*/][/*BACK_RIGHT*/5]=M_SQRT1_2*SQRT3_2;
1703     downmix_matrix[0/*links*/][/*SIDE_LEFT*/9 ]=-M_SQRT1_2*SQRT3_2;
1704     downmix_matrix[1/*rechts*/][/*SIDE_LEFT*/9]=M_SQRT1_2*M_SQRT1_2;
1705     downmix_matrix[0/*links*/][/*SIDE_RIGHT*/10 ]=-M_SQRT1_2*M_SQRT1_2;
1706     downmix_matrix[1/*rechts*/][/*SIDE_RIGHT*/10]=M_SQRT1_2*SQRT3_2;
1707     downmix_matrix[0/*links*/][/*FRONT_LEFT_OF_CENTER*/6]=1.;
1708     downmix_matrix[1/*rechts*/][/*FRONT_RIGHT_OF_CENTER*/7]=1.;
1709     downmix_matrix[0/*links*/][/*LOW_FREQUENCY*/3]=M_SQRT1_2;
1710     downmix_matrix[1/*rechts*/][/*LOW_FREQUENCY*/3]=M_SQRT1_2;
1711
1712     for (i=0,j=0;i<64;i++) {
1713         if ((1ULL << i)& channels) {
1714                 left_mat[j]=(int)(downmix_matrix[0][i]*(1<<16));
1715                 right_mat[j]=(int)(downmix_matrix[1][i]*(1<<16));
1716                 j++;
1717         }
1718     }
1719 }
1720
1721 #endif
1722
1723 void AudioOMX::PrepareMediaSample(const MediaPacketList& mplist,UINT samplepos)
1724 {
1725   packet = mplist.front();
1726 }
1727
1728 UINT AudioOMX::DeliverMediaSample(UCHAR* buffer, UINT* samplepos) {
1729         DeliverMediaPacket(packet, buffer, samplepos);
1730         if (*samplepos == packet.length) {
1731                 *samplepos = 0;
1732                 return 1;
1733         } else
1734                 return 0;
1735 }
1736
1737
1738 long long AudioOMX::correctAudioLatency(long long pts,int addsamples,int srate) {
1739
1740         VideoOMX *video = (VideoOMX*) Video::getInstance();
1741         video->LockClock();
1742         OMX_PARAM_U32TYPE audio_lat;
1743         OMX_ERRORTYPE error;
1744         memset(&audio_lat, 0, sizeof(audio_lat));
1745         audio_lat.nSize = sizeof(audio_lat);
1746         audio_lat.nVersion.nVersion = OMX_VERSION;
1747         audio_lat.nPortIndex = omx_rend_input_port;
1748
1749         error = OMX_GetConfig(omx_aud_rend, OMX_IndexConfigAudioRenderingLatency,
1750                         &audio_lat);
1751          video->UnlockClock();
1752         if (error != OMX_ErrorNone) {
1753                 Log::getInstance()->log("Audio", Log::DEBUG,
1754                                 "Init OMX_IndexConfigAudioRenderingLatencyfailed %x %d", error,
1755                                 omx_rend_input_port);
1756                 return pts; // no correction in case of error
1757         }
1758         /*Log::getInstance()->log("Audio", Log::DEBUG, "Current audio latency %d",
1759                         audio_lat.nU32);*/
1760
1761         long long workpts=0;
1762         workpts+=addsamples;
1763         workpts-=audio_lat.nU32;
1764         workpts*=10LL*1000LL*1000LL;
1765         workpts=workpts/((long long)srate); //one second /samplerate
1766         workpts+=pts;
1767
1768         return workpts;
1769 }
1770
1771 bool AudioOMX::DrainTargetBufferFull()
1772 {
1773         //Check, if we have OMX output buffers
1774         bool full;
1775         input_bufs_omx_mutex.Lock();
1776         full=(input_bufs_omx_free.size()==0);
1777         input_bufs_omx_mutex.Unlock();
1778         return full;
1779
1780 }
1781
1782
1783 UINT AudioOMX::DeliverMediaPacket(MediaPacket packet, const UCHAR* buffer,
1784                 UINT *samplepos) {
1785         /*First Check, if we have an audio sample*/
1786         VideoOMX *vw = (VideoOMX*) Video::getInstance();
1787         bool achange=false;
1788         OMX_ERRORTYPE error;
1789         Log *logger=Log::getInstance();
1790         if (vw->InIframemode()) {
1791                 samplepos = 0;
1792                 MILLISLEEP(10);
1793                 return 0; //Not in iframe mode!
1794         }
1795
1796         if (!omx_running) return 0; // if we are not runnig do not do this
1797         if (vw->isClockPaused()) return 0; //Block if we pause
1798         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 1");
1799
1800         //Log::getInstance()->log("Audio", Log::DEBUG, "DeliverMediaPacketOMX time %lld",packet.presentation_time);
1801
1802 /*      if (packet.synched && packet.presentation_time <= 0) {
1803                 *samplepos = packet.length;
1804                 firstsynched = false;
1805                 lsync=true;
1806                 Log::getInstance()->log("Audio", Log::DEBUG,
1807                                 "DeliverMediaPacketOMX Frameskip");
1808                 return packet.length;
1809         }*/
1810
1811         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 2");
1812
1813         UINT headerstrip = 0;
1814         if (packet.disconti) {
1815                 firstsynched = false;
1816                 decompress_buffer_filled=0;
1817                 if (cur_input_buf_omx) {
1818                         OMX_ERRORTYPE error = vw->ProtOMXEmptyThisBuffer(omx_aud_rend/*dec*/,
1819                                         cur_input_buf_omx);
1820                         if (error != OMX_ErrorNone) {
1821                                 Log::getInstance()->log("Audio", Log::DEBUG,
1822                                                 "OMX_EmptyThisBuffer 1 failed %x", error);
1823                         }
1824                         cur_input_buf_omx = NULL;
1825                 }
1826                 lsync=true;
1827         }
1828         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 3");
1829         if (packet.type != lastAType) {//Format Change //Push data out !
1830                 firstsynched = false;
1831                 achange=true;
1832                 Log::getInstance()->log("Audio", Log::DEBUG,"Notice audio type change %d %d", packet.type,lastAType);
1833                 lastAType = packet.type;
1834                 decompress_buffer_filled=0;
1835
1836                 if (cur_input_buf_omx) {
1837                         OMX_ERRORTYPE error = vw->ProtOMXEmptyThisBuffer(omx_aud_rend/*dec*/,
1838                                         cur_input_buf_omx);
1839                         if (error != OMX_ErrorNone) {
1840                                 Log::getInstance()->log("Audio", Log::DEBUG,
1841                                                 "OMX_EmptyThisBuffer 2 failed %x", error);
1842                         }
1843                         cur_input_buf_omx = NULL;
1844                 }
1845
1846                 int oldcancelstate;
1847                 int oldcanceltype;
1848                 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
1849                 pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldcanceltype);
1850                 vw->LockClock();
1851                 if (!ChangeAudioPortConfig(true)) {
1852                         Log::getInstance()->log("Audio", Log::DEBUG,
1853                                         "Changing audio port config failed", error);
1854                 }
1855                 vw->UnlockClock();
1856                 pthread_setcancelstate(oldcancelstate, NULL);
1857                 pthread_setcanceltype(oldcanceltype, NULL);
1858                 lsync=true;
1859
1860         }
1861         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 4");
1862
1863         /*Inspect PES-Header */
1864         if (*samplepos == 0 && packet.type != MPTYPE_MPEG_AUDIO_LAYER3) {//stripheader
1865                 headerstrip = buffer[packet.pos_buffer + 8] + 9;
1866                 if (packet.type == MPTYPE_AC3)
1867                         headerstrip += 4; //skip ac3 bytes
1868                 *samplepos += headerstrip;
1869                 if (packet.synched) {
1870                         if (cur_input_buf_omx) {
1871                                 //cur_input_buf_omx->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
1872                                 OMX_ERRORTYPE error = vw->ProtOMXEmptyThisBuffer(omx_aud_rend/*dec*/,
1873                                                 cur_input_buf_omx);
1874                                 if (error != OMX_ErrorNone) {
1875                                         Log::getInstance()->log("Audio", Log::DEBUG,
1876                                                         "OMX_EmptyThisBuffer 3 failed %x", error);
1877                                 }
1878                                  //vw->AdjustAudioPTS(correctAudioLatency(lastreftimeOMX,cur_input_buf_omx->nFilledLen/(2*2),48000));
1879
1880                                 cur_input_buf_omx = NULL;//write out old data
1881                         }
1882                         firstsynched = true;
1883                         //decompress_buffer_filled=0;
1884                 } else {
1885                         if (!firstsynched) {//
1886                                 *samplepos = packet.length;//if we have not processed at least one
1887                                 decompress_buffer_filled=0;
1888                                 //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 5");
1889                                 return packet.length;//synched packet ignore it!
1890                         }
1891                 }
1892         }
1893         if (!cur_input_buf_omx) {
1894                 input_bufs_omx_mutex.Lock();
1895                 if (input_bufs_omx_free.size()==0) {
1896                         input_bufs_omx_mutex.Unlock();
1897                         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 6");
1898                         //Log::getInstance()->log("Audio", Log::DEBUG, "Deliver MediaPacket no free sample");
1899                         return 0; // we do not have a free media sample
1900
1901                 }
1902                 cur_input_buf_omx=input_bufs_omx_free.front();
1903                 cur_input_buf_omx->nFilledLen=0;
1904                 cur_input_buf_omx->nOffset=0;
1905                 cur_input_buf_omx->nTimeStamp=VideoOMX::intToOMXTicks(0);
1906                 input_bufs_omx_free.pop_front();
1907                 input_bufs_omx_mutex.Unlock();
1908         }
1909         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 7");
1910
1911         if (cur_input_buf_omx->nFilledLen == 0) {//will only be changed on first packet
1912                 if (packet.synched) {
1913                         //Log::getInstance()->log("Audio", Log::DEBUG,
1914                         //              "packet synched marker");
1915
1916                         //lastreftimePTS=packet.pts;
1917                         if (omx_first_frame) { // TODO time
1918                                 cur_input_buf_omx->nFlags = OMX_BUFFERFLAG_STARTTIME;
1919                                 Log::getInstance()->log("Audio", Log::DEBUG, "Starttime");
1920                                 omx_first_frame = false;
1921                         } else {
1922                                 cur_input_buf_omx->nFlags = 0;
1923                                 //cur_input_buf_omx->nFlags|=OMX_BUFFERFLAG_TIME_UNKNOWN;
1924                         }
1925                         lastreftimeOMX = packet.presentation_time;
1926                         //Log::getInstance()->log("Audio", Log::DEBUG,
1927                                 //      "Time code %lld pts %lld dts %lld", lastreftimeOMX, packet.pts,packet.dts);
1928                         lastreftimePTS = packet.pts;
1929                         cur_input_buf_omx->nTimeStamp = VideoOMX::intToOMXTicks(lastreftimeOMX/10LL); // the clock component is faulty;
1930                 } else {
1931                 //      Log::getInstance()->log("Audio", Log::DEBUG,
1932                         //                                      "packet NOT synched marker");
1933                         cur_input_buf_omx->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN;
1934                         cur_input_buf_omx->nTimeStamp = VideoOMX::intToOMXTicks(0);
1935
1936                 }
1937                 if (packet.disconti || achange) {
1938                         cur_input_buf_omx->nFlags |= OMX_BUFFERFLAG_DISCONTINUITY;
1939                         //mp23codec_context_libav->frame_size=-1;
1940                         //ac3codec_context_libav->frame_size=-1;
1941                 }
1942
1943         }
1944         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 8");
1945
1946         if (*samplepos>packet.length) *samplepos=0; //propably the thread got interrupted and sample is not valid any more!
1947         unsigned int haveToCopy=packet.length-*samplepos;
1948
1949         if (passthrough) {
1950                 while (haveToCopy>0) {
1951                         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 9");
1952                         if (lsync) {
1953                                 unsigned int gotframesize=0;
1954                                 int adv=0;
1955                                 switch (packet.type) {
1956                                 case MPTYPE_MPEG_AUDIO:
1957                                 case MPTYPE_MPEG_AUDIO_LAYER3: {
1958                                         adv = AdvanceMpAudioSync(buffer+packet.pos_buffer+*samplepos,
1959                                                         haveToCopy,&gotframesize);
1960                                 }
1961                                 break;
1962                                 case MPTYPE_AC3:
1963                                 case MPTYPE_AC3_PRE13: {
1964                                         adv = AdvanceAc3AudioSync(buffer+packet.pos_buffer+*samplepos,
1965                                                         haveToCopy,&gotframesize);
1966                                 }
1967                                 break;
1968
1969                                 case MPTYPE_AAC_LATM: {
1970                                         adv = AdvanceAacLatmAudioSync(buffer+packet.pos_buffer+*samplepos,
1971                                                         haveToCopy,&gotframesize);
1972                                 }
1973                                 break;
1974                                 };
1975                                 if (adv!=haveToCopy) {
1976                                         lsync=false;
1977                                         haveToCopy-=adv;
1978                                         *samplepos+=adv;
1979                                 } else {
1980                                         *samplepos=packet.length; //no ac3 sync byte
1981                                         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 10");
1982                                         return packet.length;
1983                                 }
1984                         }
1985                         // so everything is fine now do a memcpy
1986                         int cancopy=min(haveToCopy,cur_input_buf_omx->nAllocLen-cur_input_buf_omx->nFilledLen);
1987                         memcpy(cur_input_buf_omx->pBuffer+cur_input_buf_omx->nFilledLen,buffer+packet.pos_buffer+*samplepos,cancopy);
1988                         haveToCopy-=cancopy;
1989                         cur_input_buf_omx->nFilledLen+=cancopy;
1990                         *samplepos+=cancopy;
1991                         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 11");
1992
1993                         error = vw->ProtOMXEmptyThisBuffer(omx_aud_rend/*dec*/, cur_input_buf_omx);
1994                         if (error != OMX_ErrorNone) {
1995                                 Log::getInstance()->log("Audio", Log::DEBUG,
1996                                                 "OMX_EmptyThisBuffer 5 failed %x", error);
1997                         }
1998                         cur_input_buf_omx=NULL;
1999                         if (haveToCopy>0) {
2000                                 // get5 new buffer
2001                                 input_bufs_omx_mutex.Lock();
2002                                 if (input_bufs_omx_free.size()==0) {
2003                                         input_bufs_omx_mutex.Unlock();
2004                                         //      Log::getInstance()->log("Audio", Log::DEBUG, "Deliver MediaPacket no free sample2");
2005                                         return *samplepos; // we do not have a free media sample
2006                                 }
2007                                 cur_input_buf_omx=input_bufs_omx_free.front();
2008                                 cur_input_buf_omx->nFilledLen=0;
2009                                 cur_input_buf_omx->nOffset=0;
2010                                 cur_input_buf_omx->nFlags=OMX_BUFFERFLAG_TIME_UNKNOWN;
2011                                 cur_input_buf_omx->nTimeStamp=VideoOMX::intToOMXTicks(0);
2012                                 input_bufs_omx_free.pop_front();
2013                                 input_bufs_omx_mutex.Unlock();
2014                         }
2015                         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 12");
2016
2017                 }
2018                 //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 13");
2019
2020         } else {
2021                 int len;
2022                 int gotta;
2023                 int framesize=0;
2024                 int errcount=0;
2025
2026                 AVCodecContext *current_context;
2027                 switch (packet.type) {
2028                 case MPTYPE_MPEG_AUDIO:
2029                 case MPTYPE_MPEG_AUDIO_LAYER3: {
2030                         current_context = mp23codec_context_libav;
2031                         if (current_context->frame_size<0) framesize=1152; //Maximum framesize
2032                         else framesize=current_context->frame_size;
2033                 }break;
2034                 case MPTYPE_AAC_LATM: {
2035                         current_context = aaclatmcodec_context_libav;
2036                 } break;
2037                 case MPTYPE_AC3:
2038                 case MPTYPE_AC3_PRE13: {
2039                         current_context = ac3codec_context_libav;
2040                 }break;
2041                 };
2042
2043                 if (decompress_buffer_filled) { // have a remaining paket
2044                         incoming_paket_libav.data =(uint8_t*) decompress_buffer;
2045                         memcpy(decompress_buffer+decompress_buffer_filled,
2046                                         buffer+packet.pos_buffer+*samplepos,
2047                                         min(haveToCopy,decompress_buffer_size-decompress_buffer_filled));
2048                         incoming_paket_libav.size = decompress_buffer_filled
2049                                         +min(haveToCopy,decompress_buffer_size-decompress_buffer_filled);
2050                         //Log::getInstance()->log("Audio", Log::DEBUG,"Use saved audio buffer %d %d %d",packet.type,decompress_buffer_filled,packet.synched);
2051                 } else {
2052                         incoming_paket_libav.data =(uint8_t*) buffer+packet.pos_buffer+*samplepos;
2053                         incoming_paket_libav.size = haveToCopy;
2054                 }
2055                 //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 18");
2056
2057                 while (haveToCopy> 0 && errcount<3) {
2058
2059                         //Log::getInstance()->log("Audio", Log::DEBUG,"libav in %d %d",framesize,current_context->frame_size);
2060                         //Log::getInstance()->log("Audio", Log::DEBUG, "libav in %d %d",
2061                                 //      framesize, current_context->frame_size);
2062
2063                         bool donotdecompress=false;
2064                         unsigned int gotframesize=0;
2065                 //      if (!decompress_buffer_filled) { // only do this if no old data is present
2066                                 int adv = 0;
2067                                 switch (packet.type) {
2068                                 case MPTYPE_MPEG_AUDIO:
2069                                 case MPTYPE_MPEG_AUDIO_LAYER3: {
2070                                         adv = AdvanceMpAudioSync(incoming_paket_libav.data,
2071                                                         incoming_paket_libav.size,&gotframesize);
2072                                 }
2073                                 break;
2074                                 case MPTYPE_AC3:
2075                                 case MPTYPE_AC3_PRE13: {
2076                                         adv = AdvanceAc3AudioSync(incoming_paket_libav.data,
2077                                                         incoming_paket_libav.size,&gotframesize);
2078                                 }
2079                                 break;
2080                                 case MPTYPE_AAC_LATM: {
2081                                         adv = AdvanceAacLatmAudioSync(incoming_paket_libav.data,
2082                                                         incoming_paket_libav.size,&gotframesize);
2083                                 }
2084                                 break;
2085                                 };
2086                                 if (adv > 0 /*&& !decompress_buffer_filled*/) {
2087                                         incoming_paket_libav.data += adv;
2088                                         incoming_paket_libav.size-=adv;
2089                                         haveToCopy -= adv;
2090                                         *samplepos += adv;
2091                                         /*if (current_context->frame_size>0) framesize=min(current_context->frame_size,haveToCopy);
2092                                         else*/ framesize=haveToCopy;
2093                                         //Log::getInstance()->log("Audio", Log::DEBUG,"Advance by %d %d from %d",adv,packet.type,*samplepos );
2094                                         if (haveToCopy <= 0) {
2095                                                 //       Log::getInstance()->log("Audio", Log::DEBUG,"No sync code in packet remove %d",packet.type);
2096                                                 *samplepos=packet.length;
2097                                                 return packet.length;
2098                                         }
2099
2100
2101                         //      } //
2102
2103                                 if (gotframesize>0 && gotframesize>haveToCopy) {
2104                                         donotdecompress=true;
2105                                         errcount=100; // exit loop
2106                                 }
2107                                 //      else Log::getInstance()->log("Audio", Log::DEBUG,"Loop run" );
2108                         }
2109                         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 19");
2110                         if (!donotdecompress) {
2111                                 int oldcancelstate;
2112                                 int oldcanceltype;
2113                                 pthread_testcancel();
2114                                 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
2115                                 pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldcanceltype);
2116                                 libav_mutex.Lock();
2117                                 if (!omx_running || !mp23codec_context_libav
2118                                                 || !ac3codec_context_libav) {
2119                                         libav_mutex.Unlock();
2120                                         return *samplepos;
2121                                 }
2122                                 libav_mutex.Unlock();
2123                                 //      Log::getInstance()->log("Audio", Log::DEBUG,"libav out");
2124                                 int save_size=incoming_paket_libav.size;
2125
2126                                 if (gotframesize<=incoming_paket_libav.size) {
2127                                         if (gotframesize>0) incoming_paket_libav.size=gotframesize;
2128                                         len = avcodec_decode_audio4(current_context, decode_frame_libav,
2129                                                 &gotta, &incoming_paket_libav);
2130                                 } else {
2131                                         //Log::getInstance()->log("Audio", Log::DEBUG, "FRAME:E %d %d",gotframesize,incoming_paket_libav.size);
2132                                         gotta=0;
2133                                         len=0;
2134                                 }
2135                                 //Log::getInstance()->log("Audio", Log::DEBUG, "FRAME:T %d",len);
2136                                 incoming_paket_libav.size=save_size;
2137                                 //Log::getInstance()->log("Audio", Log::DEBUG, "libav out1");
2138                                 pthread_setcancelstate(oldcancelstate, NULL);
2139                                 pthread_setcanceltype(oldcanceltype, NULL);
2140                                 pthread_testcancel();
2141
2142                         } else {
2143                                 gotta=0;
2144                                 len=0;
2145                         }
2146                         //Log::getInstance()->log("Audio", Log::DEBUG, "libav out2");
2147                         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 20");
2148                         if (!omx_running) {
2149                                 libav_mutex.Unlock();
2150                                 return *samplepos;
2151                         }
2152
2153                         if (decompress_buffer_filled) { // reset to normal decoding
2154                                 if (len>0) {
2155                                         //Log::getInstance()->log("Audio", Log::DEBUG,"saved audio: %d",len);
2156                                         haveToCopy -= min(len-decompress_buffer_filled,0);
2157                                         *samplepos += min(len-decompress_buffer_filled,0);
2158                                         //if (current_context->frame_size>0) framesize=min(current_context->frame_size,haveToCopy);
2159                                         /*else*/ framesize=haveToCopy;
2160                                 } else {
2161                                         framesize=haveToCopy;
2162                                 }
2163                                 incoming_paket_libav.data =(uint8_t*) buffer+packet.pos_buffer+*samplepos;
2164                                 errcount=0;
2165                                 decompress_buffer_filled=0;
2166                         } else {
2167
2168                                 if (len>0) {
2169                                         incoming_paket_libav.data += len;
2170                                         haveToCopy -= len;
2171                                         *samplepos += len;
2172                                         errcount=0;
2173                                         /*if (current_context->frame_size>0) framesize=min(current_context->frame_size,haveToCopy);
2174                                         else*/framesize=haveToCopy;
2175                                 } else {
2176                                         errcount++;
2177                                         framesize=haveToCopy;
2178                                 }
2179                         }
2180                         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 21");
2181
2182                         incoming_paket_libav.size =framesize;
2183                         if (gotta) {
2184                                 //Log::getInstance()->log("Audio", Log::DEBUG,
2185                                 //                                      "Got a frame");
2186
2187                                 int dsize = av_samples_get_buffer_size(NULL,
2188                                                 /*current_context->channels*/2, decode_frame_libav->nb_samples,
2189                                                 current_context->sample_fmt, 1);
2190                                 int dsize_in = av_samples_get_buffer_size(NULL,
2191                                                                                 current_context->channels, decode_frame_libav->nb_samples,
2192                                                                                 current_context->sample_fmt, 1);
2193                                 //if (current_context->channels==1) dsize*=2; // we convert mono to stereo
2194                                 if ((cur_input_buf_omx->nFilledLen + dsize)
2195                                                 > cur_input_buf_omx->nAllocLen ) {
2196                                         // I doubt that this will ever happen
2197                                 //      Log::getInstance()->log("Audio", Log::DEBUG,
2198                                         //                                      "P 2 Time code %lld pts %lld", lastreftimeOMX, packet.pts);
2199                                         OMX_ERRORTYPE error = vw->ProtOMXEmptyThisBuffer(omx_aud_rend/*dec*/,
2200                                                         cur_input_buf_omx);
2201                                         if (error != OMX_ErrorNone) {
2202                                                 Log::getInstance()->log("Audio", Log::DEBUG,
2203                                                                 "OMX_EmptyThisBuffer 4 failed %x", error);
2204                                         }
2205                                         cur_input_buf_omx = NULL;
2206
2207                                         if (!cur_input_buf_omx) {
2208                                                 int count = 0;
2209                                                 while (count < 10 && omx_running) {
2210                                                         count++;
2211                                                         input_bufs_omx_mutex.Lock();
2212                                                         if (input_bufs_omx_free.size() == 0) {
2213                                                                 input_bufs_omx_mutex.Unlock();
2214                                                         //      Log::getInstance()->log("Audio", Log::DEBUG,
2215                                                                 //              "Deliver MediaPacket no free sample");
2216                                                                 MILLISLEEP(5);
2217                                                                 //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark22");
2218                                                                 if (!omx_running) return *samplepos;
2219                                                                 //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 23");
2220                                                                 continue;
2221                                                         }
2222                                                         cur_input_buf_omx = input_bufs_omx_free.front();
2223                                                         cur_input_buf_omx->nFilledLen = 0;
2224                                                         cur_input_buf_omx->nOffset = 0;
2225                                                         cur_input_buf_omx->nTimeStamp = VideoOMX::intToOMXTicks(0);
2226                                                         cur_input_buf_omx->nFlags=OMX_BUFFERFLAG_TIME_UNKNOWN;
2227                                                         input_bufs_omx_free.pop_front();
2228                                                         input_bufs_omx_mutex.Unlock();
2229                                                         break;
2230                                                 }
2231                                                 if (!cur_input_buf_omx) return *samplepos;
2232                                         }
2233
2234                                 }
2235
2236                                 //Log::getInstance()->log("Audio", Log::DEBUG,"memcpy in %d %d %d" ,dsize,current_context->sample_rate,cur_input_buf_omx->nFilledLen);
2237                                 if (current_context->channels==2) {
2238                                         memcpy(cur_input_buf_omx->pBuffer + cur_input_buf_omx->nFilledLen,
2239                                                         decode_frame_libav->data[0], dsize);
2240                                 }
2241 #ifndef USE_LIBRESAMPLE
2242                                 else if (current_context->channels==1) { //convert to stereo
2243                                         short* startbuffer=(short* )decode_frame_libav->data[0];
2244                                         short* endbuffer=(short* )(decode_frame_libav->data[0]+dsize/2);
2245                                         short* destbuffer=(short* )(cur_input_buf_omx->pBuffer + cur_input_buf_omx->nFilledLen);
2246                                         while (startbuffer!=endbuffer) {
2247                                                 unsigned short temp=*startbuffer;
2248                                                 *destbuffer=temp;
2249                                                 destbuffer++;
2250                                                 *destbuffer=temp;
2251                                                 destbuffer++;
2252                                                 startbuffer++;
2253                                         }
2254                                 } else {
2255                                         unsigned int channels=current_context->channels;
2256                                         int left_mat[channels];
2257                                         int right_mat[channels];
2258                                         getDownMixMatrix(current_context->channel_layout,left_mat,right_mat);
2259
2260                         short* startbuffer=(short* )decode_frame_libav->data[0];
2261                                         short* endbuffer=(short* )(decode_frame_libav->data[0]+dsize_in);
2262                                         short* destbuffer=(short* )(cur_input_buf_omx->pBuffer + cur_input_buf_omx->nFilledLen);
2263                                         while (startbuffer!=endbuffer) {
2264                                                 short* cur_buf=startbuffer;
2265                                                 short* cur_buf_end=startbuffer+channels;
2266                                                 int work1=0.;
2267                                                 int work2=0.;
2268                                                 int *mat1=left_mat;
2269                                                 int *mat2=right_mat;
2270                                                 while (cur_buf!=cur_buf_end) {
2271                                                         work1+= ((*mat1)*(*cur_buf));
2272                                                         work2+= ((*mat2)*(*cur_buf));
2273                                                         cur_buf++;
2274                                                         mat1++;
2275                                                         mat2++;
2276                                                 }
2277                                                 *destbuffer=work1>>16;
2278                                                 destbuffer++;
2279                                                 *destbuffer=work2>>16;
2280                                                 destbuffer++;
2281                                                 startbuffer+=channels;
2282
2283                                         }
2284
2285                                 }
2286 #else
2287                                 else {
2288                                         //untested for future use
2289                                         av_opt_set_int(resam_con_libav, "in_sample_rate",current_context->sample_rate,0);
2290                                         av_opt_set_int(resam_con_libav, "in_sample_fmt",current_context->sample_fmt,0);
2291                                         av_opt_set_int(resam_con_libav, "in_channel_layout",current_context->channel_layout, 0);
2292                                         int ret=avresample_open(resam_con_libav);
2293                                         if (ret<0) {
2294                                                 Log::getInstance()->log("Audio", Log::ERR,"Opening AV resample failed %d",ret);
2295                                         } else {
2296                                                 avresample_convert(resam_con_libav, cur_input_buf_omx->pBuffer + cur_input_buf_omx->nFilledLen,
2297                                                                 dsize, decode_frame_libav->nb_samples,
2298                                                                 decode_frame_libav->data[0],  dsize_in,  decode_frame_libav->nb_samples);
2299                                                 avresample_close(resam_con_libav);
2300                                         }
2301
2302                                 }
2303 #endif
2304
2305                                 //Log::getInstance()->log("Audio", Log::DEBUG,"memcpy out");
2306                                 cur_input_buf_omx->nFilledLen += dsize;
2307                         } else {
2308                                 //Log::getInstance()->log("Audio", Log::DEBUG,"Incomplete mpeg frames in pes packet %d %d",incoming_paket_libav.size,packet.length);
2309                         /*      uint8_t a1=incoming_paket_libav.data[0];
2310                                 uint8_t a2=incoming_paket_libav.data[1];
2311                                 uint8_t a3=incoming_paket_libav.data[2];
2312                                 uint8_t a4=incoming_paket_libav.data[3];*/
2313                         //      Log::getInstance()->log("Audio", Log::DEBUG,"Header %x %x %x %x",a1,a2,
2314                                 //              a3,a4);
2315                         }
2316
2317                 }
2318                 //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 24");
2319                 decompress_buffer_filled=0;
2320                 if (haveToCopy ) {
2321                         //Log::getInstance()->log("Audio", Log::DEBUG,"We can not decompress %d save for later %d %x %x",haveToCopy,packet.type,incoming_paket_libav.data,packet.pos_buffer);
2322                         memcpy(decompress_buffer,incoming_paket_libav.data,min(haveToCopy,decompress_buffer_size));
2323
2324                         decompress_buffer_filled=min(haveToCopy,decompress_buffer_size);
2325
2326                 }
2327
2328                 if (cur_input_buf_omx->nFilledLen) {
2329                         //Log::getInstance()->log("Audio", Log::DEBUG,
2330                         //                                                              "P 3 Time code %lld pts %lld", lastreftimeOMX, packet.pts);
2331                         error = vw->ProtOMXEmptyThisBuffer(omx_aud_rend/*dec*/, cur_input_buf_omx);
2332                         if (error != OMX_ErrorNone) {
2333                                 Log::getInstance()->log("Audio", Log::DEBUG,
2334                                                 "OMX_EmptyThisBuffer 5 failed %x", error);
2335                         }
2336                         //if (packet.synched) vw->AdjustAudioPTS(correctAudioLatency(lastreftimeOMX,cur_input_buf_omx->nFilledLen/(2*2),48000));
2337                         cur_input_buf_omx = NULL;
2338                 }
2339         }
2340
2341
2342         //Log::getInstance()->log("Audio", Log::DEBUG, "DMP mark 25");
2343
2344         *samplepos=packet.length;
2345         return packet.length;
2346
2347 }
2348
2349
2350
2351 long long AudioOMX::SetStartOffset(long long curreftime, bool *rsync){
2352   VideoOMX *vw=(VideoOMX*)Video::getInstance();
2353   return vw->SetStartAudioOffset(curreftime,rsync);
2354 }
2355
2356 void AudioOMX::ResetTimeOffsets() {
2357   VideoOMX *vw=(VideoOMX*)Video::getInstance();
2358   vw->ResetTimeOffsets();
2359 }
2360
2361