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