audioomx.cc

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