audioomx.cc

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