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