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