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