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