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