audioomx.cc

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