audioomx.cc

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