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