OpenMAXBellagio: omxaudiodectest.c Source File

00001 
00034 #include "omxaudiodectest.h"
00035 
00036 #define MP3_TYPE_SEL    1
00037 #define VORBIS_TYPE_SEL 2
00038 #define AAC_TYPE_SEL    3 
00039 #define COMPONENT_NAME_BASE "OMX.st.audio_decoder"
00040 #define BASE_ROLE "audio_decoder.ogg"
00041 #define COMPONENT_NAME_BASE_LEN 20
00042 #define SINK_NAME "OMX.st.alsa.alsasink"
00043 #define FILE_READER "OMX.st.audio_filereader"
00044 #define AUDIO_EFFECT "OMX.st.volume.component"
00045 #define extradata_size 1024
00046 
00047 appPrivateType* appPriv;
00048 
00049 OMX_BUFFERHEADERTYPE *outBufferFileRead1, *outBufferFileRead2;
00050 OMX_BUFFERHEADERTYPE *inBufferAudioDec1, *inBufferAudioDec2,*outBufferAudioDec1, *outBufferAudioDec2;
00051 OMX_BUFFERHEADERTYPE *inBufferVolume1, *inBufferVolume2,*outBufferVolume1, *outBufferVolume2;
00052 OMX_BUFFERHEADERTYPE *inBufferSink1, *inBufferSink2;
00053 int buffer_in_size = BUFFER_IN_SIZE; 
00054 int buffer_out_size = BUFFER_OUT_SIZE;
00055 static OMX_BOOL bEOS=OMX_FALSE;
00056 
00057 OMX_CALLBACKTYPE audiodeccallbacks = { 
00058   .EventHandler    = audiodecEventHandler,
00059   .EmptyBufferDone = audiodecEmptyBufferDone,
00060   .FillBufferDone  = audiodecFillBufferDone
00061 };
00062 
00063 OMX_CALLBACKTYPE audiosinkcallbacks = { 
00064   .EventHandler    = audiosinkEventHandler,
00065   .EmptyBufferDone = audiosinkEmptyBufferDone,
00066   .FillBufferDone  = NULL
00067 };
00068 
00069 OMX_CALLBACKTYPE filereadercallbacks = { 
00070   .EventHandler    = filereaderEventHandler,
00071   .EmptyBufferDone = NULL,
00072   .FillBufferDone  = filereaderFillBufferDone
00073 };
00074 
00075 OMX_CALLBACKTYPE volumecallbacks = { 
00076   .EventHandler    = volumeEventHandler,
00077   .EmptyBufferDone = volumeEmptyBufferDone,
00078   .FillBufferDone  = volumeFillBufferDone
00079 };
00080 
00081 FILE *fd ,*outfile;
00082 char *input_file, *output_file;
00083 int selectedType = 0;
00084 
00085 static void setHeader(OMX_PTR header, OMX_U32 size) {
00086   OMX_VERSIONTYPE* ver = (OMX_VERSIONTYPE*)(header + sizeof(OMX_U32));
00087   *((OMX_U32*)header) = size;
00088 
00089   ver->s.nVersionMajor = VERSIONMAJOR;
00090   ver->s.nVersionMinor = VERSIONMINOR;
00091   ver->s.nRevision = VERSIONREVISION;
00092   ver->s.nStep = VERSIONSTEP;
00093 }
00094 
00095 
00096 void display_help() {
00097   printf("\n");
00098   printf("Usage: omxaudiodectest [-o outfile] [-stmdgh] filename\n");
00099   printf("\n");
00100   printf("       -o outfile: If this option is specified, the decoded stream is written to outfile\n");
00101   printf("                   This option can't be used with '-t' \n");
00102   printf("       -s single_ogg: Use the single role Ogg Vorbis decoder instead of the default one. Can't be used with -m or .mp3 file\n");
00103   printf("       -t: The audio decoder is tunneled with the alsa sink\n");
00104   printf("       -m: For MP3 decoding use the mad library. Can't be used with -s or .ogg file\n");
00105   printf("       -d: If no output is specified, and no playback is specified,\n");
00106   printf("           this flag activated the print of the stream directly on stdout\n");
00107   printf("       -f: Use filereader with mad\n");
00108   printf("       -g: Gain of the audio sink[0...100]\n");
00109   printf("       -h: Displays this help\n");
00110   printf("\n");
00111   exit(1);
00112 }
00113 
00114 OMX_ERRORTYPE test_OMX_ComponentNameEnum() {
00115   char * name;
00116   int index;
00117 
00118   OMX_ERRORTYPE err = OMX_ErrorNone;
00119 
00120   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00121   name = malloc(OMX_MAX_STRINGNAME_SIZE);
00122   index = 0;
00123   while(1) {
00124     err = OMX_ComponentNameEnum (name, OMX_MAX_STRINGNAME_SIZE, index);
00125     if ((name != NULL) && (err == OMX_ErrorNone)) {
00126       DEBUG(DEFAULT_MESSAGES, "component %i is %s\n",index, name);
00127     } else break;
00128     if (err != OMX_ErrorNone) break;
00129       index++;
00130   }
00131   free(name);
00132   name = NULL;
00133   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00134   return err;
00135 }
00136 
00137 OMX_ERRORTYPE test_OMX_RoleEnum(OMX_STRING component_name) {
00138   OMX_U32 no_of_roles;
00139   OMX_U8 **string_of_roles;
00140   OMX_ERRORTYPE err = OMX_ErrorNone;
00141   int index;
00142 
00143   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00144   DEBUG(DEB_LEV_SIMPLE_SEQ, "Getting roles of %s. Passing Null first...\n", component_name);
00145   err = OMX_GetRolesOfComponent(component_name, &no_of_roles, NULL);
00146   if (err != OMX_ErrorNone) {
00147     DEBUG(DEB_LEV_ERR, "Not able to retrieve the number of roles of the given component\n");
00148     DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00149     return err;
00150   }
00151   DEBUG(DEFAULT_MESSAGES, "The number of roles for the component %s is: %i\n", component_name, (int)no_of_roles);
00152 
00153   if(no_of_roles == 0) {
00154     DEBUG(DEB_LEV_ERR, "The Number or roles is 0.\nThe component selected is not correct for the purpose of this test.\nExiting...\n");    
00155     err = OMX_ErrorInvalidComponentName;
00156   }  else {
00157     string_of_roles = (OMX_U8**)malloc(no_of_roles * sizeof(OMX_STRING));
00158     for (index = 0; index<no_of_roles; index++) {
00159       *(string_of_roles + index) = (OMX_U8 *)malloc(no_of_roles*OMX_MAX_STRINGNAME_SIZE);
00160     }
00161     DEBUG(DEB_LEV_SIMPLE_SEQ, "...then buffers\n");
00162 
00163     err = OMX_GetRolesOfComponent(component_name, &no_of_roles, string_of_roles);
00164     if (err != OMX_ErrorNone) {
00165       DEBUG(DEB_LEV_ERR, "Not able to retrieve the roles of the given component\n");
00166     } else if(string_of_roles != NULL) {
00167       for (index = 0; index < no_of_roles; index++) {
00168         DEBUG(DEFAULT_MESSAGES, "The role %i for the component:  %s \n", (index + 1), *(string_of_roles+index));
00169       }
00170     } else {
00171       DEBUG(DEB_LEV_ERR, "role string is NULL!!! Exiting...\n");
00172       err = OMX_ErrorInvalidComponentName;
00173     }
00174     for (index = 0; index<no_of_roles; index++) {
00175       free(*(string_of_roles + index));
00176     }
00177     free(string_of_roles);
00178   }
00179   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00180   return err;
00181 }
00182 
00183 OMX_ERRORTYPE test_OMX_ComponentEnumByRole(OMX_STRING role_name) {
00184   OMX_U32 no_of_comp_per_role;
00185   OMX_U8 **string_of_comp_per_role;
00186   OMX_ERRORTYPE err;
00187   int index;
00188 
00189   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00190   
00191   DEBUG(DEFAULT_MESSAGES, "Getting number of components per role for %s\n", role_name);
00192 
00193   err = OMX_GetComponentsOfRole(role_name, &no_of_comp_per_role, NULL);
00194   if (err != OMX_ErrorNone) {
00195     DEBUG(DEB_LEV_ERR, "Not able to retrieve the number of components of a given role\n");
00196     DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00197     return err;
00198   }
00199   DEBUG(DEFAULT_MESSAGES, "Number of components per role for %s is %i\n", role_name, (int)no_of_comp_per_role);
00200 
00201   string_of_comp_per_role = (OMX_U8**)malloc(no_of_comp_per_role * sizeof(OMX_STRING));
00202   for (index = 0; index<no_of_comp_per_role; index++) {
00203     string_of_comp_per_role[index] = malloc(OMX_MAX_STRINGNAME_SIZE);
00204   }
00205 
00206   err = OMX_GetComponentsOfRole(role_name, &no_of_comp_per_role, string_of_comp_per_role);
00207   if (err != OMX_ErrorNone) {
00208     DEBUG(DEB_LEV_ERR, "Not able to retrieve the components of a given role\n");
00209     DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00210     for (index = 0; index<no_of_comp_per_role; index++) {
00211       if(string_of_comp_per_role[index]) {
00212         free(string_of_comp_per_role[index]);
00213         string_of_comp_per_role[index] = NULL;
00214       }
00215     }
00216 
00217     if(string_of_comp_per_role)  {
00218       free(string_of_comp_per_role);
00219       string_of_comp_per_role = NULL;
00220     }
00221     return err;
00222   }
00223 
00224   DEBUG(DEFAULT_MESSAGES, " The components are:\n");
00225   for (index = 0; index < no_of_comp_per_role; index++) {
00226     DEBUG(DEFAULT_MESSAGES, "%s\n", string_of_comp_per_role[index]);
00227   }
00228   for (index = 0; index<no_of_comp_per_role; index++) {
00229     if(string_of_comp_per_role[index]) {
00230       free(string_of_comp_per_role[index]);
00231       string_of_comp_per_role[index] = NULL;
00232     }
00233   }
00234 
00235   if(string_of_comp_per_role)  {
00236     free(string_of_comp_per_role);
00237     string_of_comp_per_role = NULL;
00238   }
00239   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result OMX_ErrorNone\n",__func__);
00240   return OMX_ErrorNone;
00241 }
00242 
00243 OMX_ERRORTYPE test_OpenClose(OMX_STRING component_name) {
00244   OMX_ERRORTYPE err = OMX_ErrorNone;
00245 
00246   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00247   err = OMX_GetHandle(&appPriv->audiodechandle, component_name, NULL /*appPriv */, &audiodeccallbacks);
00248   if(err != OMX_ErrorNone) {
00249     DEBUG(DEB_LEV_ERR, "No component found\n");
00250   } else {
00251     err = OMX_FreeHandle(appPriv->audiodechandle);
00252     if(err != OMX_ErrorNone) {
00253       DEBUG(DEB_LEV_ERR, "In %s err %08x in Free Handle\n",__func__,err);
00254     }
00255   }
00256   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00257   return err;
00258 }
00259 
00260 int flagIsOutputExpected;
00261 int flagSetupTunnel;
00262 int flagPlaybackOn;
00263 int flagOutputReceived;
00264 int flagInputReceived;
00265 int flagIsMadRequested;
00266 int flagIsMadUsingFileReader;
00267 int flagDirect;
00268 int flagSingleOGGSelected;
00269 int flagUsingFFMpeg;
00270 int flagIsGain;
00271 
00272 
00273 int main(int argc, char** argv) {
00274   int argn_dec;
00275   char *temp = NULL;
00276   OMX_ERRORTYPE err;
00277   OMX_INDEXTYPE eIndexParamFilename;
00278   OMX_STRING full_component_name;
00279   int index;
00280   int data_read;
00281   int gain=-1;
00282   OMX_AUDIO_CONFIG_VOLUMETYPE sVolume;
00283 
00284   if(argc < 2){
00285     display_help();
00286   } else {
00287     flagIsOutputExpected = 0;
00288     flagSetupTunnel = 0;
00289     flagPlaybackOn = 1;
00290     flagOutputReceived = 0;
00291     flagInputReceived = 0;
00292     flagIsMadRequested = 0;
00293     flagIsMadUsingFileReader = 0;
00294     flagDirect = 0;
00295     flagSingleOGGSelected = 0;
00296     flagUsingFFMpeg = 1;
00297     flagIsGain = 0;
00298 
00299     argn_dec = 1;
00300     while (argn_dec<argc) {
00301       if (*(argv[argn_dec]) =='-') {
00302         if (flagIsOutputExpected) {
00303           display_help();
00304         }
00305         switch (*(argv[argn_dec]+1)) {
00306         case 'h':
00307           display_help();
00308           break;
00309         case 's':
00310           flagSingleOGGSelected = 1;
00311           flagUsingFFMpeg = 0;
00312           break;
00313         case 't':
00314           flagSetupTunnel = 1;
00315           break;
00316         case 'o':
00317           flagIsOutputExpected = 1;
00318           flagPlaybackOn = 0;
00319           break;
00320         case 'm':
00321           flagIsMadRequested = 1;
00322           flagUsingFFMpeg = 0;
00323           break;
00324         case 'f':
00325           flagIsMadUsingFileReader = 1;
00326           break;
00327         case 'd':
00328           flagDirect = 1;
00329           flagPlaybackOn = 0;
00330           break;
00331         case 'g':
00332           flagIsGain = 1;
00333           break;
00334         default:
00335           display_help();
00336         }
00337       } else {
00338         if (flagIsGain) {
00339           gain = (int)atoi(argv[argn_dec]);
00340           flagIsGain = 0;
00341           if(gain > 100) {
00342             DEBUG(DEFAULT_MESSAGES, "Gain should be between [0..100]\n");
00343             gain = 100; 
00344           }
00345         } else if (flagIsOutputExpected) {
00346           output_file = malloc(strlen(argv[argn_dec]) + 1);
00347           strcpy(output_file,argv[argn_dec]);
00348           flagIsOutputExpected = 0;
00349           flagOutputReceived = 1;
00350         } else {
00351           input_file = malloc(strlen(argv[argn_dec]) + 1);
00352           strcpy(input_file,argv[argn_dec]);
00353           flagInputReceived = 1;
00354         }
00355       }
00356       argn_dec++;
00357     }
00358     if (flagSetupTunnel) {
00359       if(flagOutputReceived) {
00360         DEBUG(DEFAULT_MESSAGES, "-o Option Ignored. No FILE output will be produced.\n");
00361         flagOutputReceived = 0;
00362       }
00363       flagPlaybackOn = 1;
00364     }
00365     if (!flagInputReceived) {
00366       display_help();
00367     }
00368     DEBUG(DEFAULT_MESSAGES, "Options selected:\n");
00369     DEBUG(DEFAULT_MESSAGES, "Decode file %s", input_file);
00370     DEBUG(DEFAULT_MESSAGES, " to ");
00371     if (flagPlaybackOn) {
00372       DEBUG(DEFAULT_MESSAGES, " ALSA sink");
00373       if (flagSetupTunnel) {
00374         DEBUG(DEFAULT_MESSAGES, " with tunneling\n");
00375       } else {
00376         DEBUG(DEFAULT_MESSAGES, " without tunneling\n");
00377       }
00378     } else {
00379       if (flagOutputReceived) {
00380         DEBUG(DEFAULT_MESSAGES, " %s\n", output_file);
00381       }
00382     }
00383   }
00384   index = 0;
00385   while(*(input_file+index) != '\0') {
00386     index++;
00387   }
00388   DEBUG(DEFAULT_MESSAGES, "Format selected ");
00389   if (*(input_file+index -1) == '3') {
00390     selectedType = MP3_TYPE_SEL;
00391     DEBUG(DEFAULT_MESSAGES, "MP3\n");
00392     if(flagSingleOGGSelected) {
00393       DEBUG(DEB_LEV_ERR, "ERROR:Wrong Format(OGG Single) Selected\n");
00394       display_help();
00395     }
00396   } else if(*(input_file+index -1) == 'g') {
00397     selectedType = VORBIS_TYPE_SEL;
00398     DEBUG(DEFAULT_MESSAGES, "VORBIS\n");
00399     if(flagIsMadRequested) {
00400       DEBUG(DEB_LEV_ERR, "ERROR:Wrong Format(MAD) Selected\n");
00401       display_help();
00402     }
00403   } else if(*(input_file+index -1) == 'c') {   
00404     selectedType = AAC_TYPE_SEL;
00405     DEBUG(DEFAULT_MESSAGES, "AAC\n");
00406     if(flagIsMadRequested || flagSingleOGGSelected) {
00407       DEBUG(DEB_LEV_ERR, "ERROR:Wrong Format(MAD/VORBIS) Selected\n");
00408       display_help();
00409     }
00410   } else {
00411     DEBUG(DEB_LEV_ERR, "The input audio format is not supported - exiting\n");
00412     exit(1);
00413   }
00414   
00415 
00416   if (flagOutputReceived) {
00417     outfile = fopen(output_file,"wb");
00418     if(outfile == NULL) {
00419       DEBUG(DEB_LEV_ERR, "Error at opening the output file");
00420       exit(1);
00421     } 
00422   }
00423 
00424   if(!flagUsingFFMpeg && !flagIsMadUsingFileReader) {
00425     fd = fopen(input_file, "rb");
00426     if(fd == NULL) {
00427       DEBUG(DEB_LEV_ERR, "Error in opening input file %s\n", input_file);
00428       exit(1);
00429     }
00430   }
00431 
00433   appPriv = malloc(sizeof(appPrivateType));
00434   appPriv->filereaderEventSem = malloc(sizeof(tsem_t));
00435   appPriv->decoderEventSem = malloc(sizeof(tsem_t));
00436   appPriv->eofSem = malloc(sizeof(tsem_t));
00437   if (flagPlaybackOn) {
00438     appPriv->sinkEventSem = malloc(sizeof(tsem_t));
00439     tsem_init(appPriv->sinkEventSem, 0);
00440     appPriv->volumeEventSem = malloc(sizeof(tsem_t));
00441     tsem_init(appPriv->volumeEventSem, 0);
00442   }
00443   tsem_init(appPriv->filereaderEventSem, 0);
00444   tsem_init(appPriv->decoderEventSem, 0);
00445   tsem_init(appPriv->eofSem, 0);
00446 
00448   err = OMX_Init();
00449   if (err != OMX_ErrorNone) {
00450     DEBUG(DEB_LEV_ERR, "The OpenMAX core can not be initialized. Exiting...\n");
00451     exit(1);
00452   } 
00453 
00454   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00455   test_OMX_ComponentNameEnum();
00456   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00457   test_OMX_RoleEnum(COMPONENT_NAME_BASE);
00458   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00459   test_OMX_ComponentEnumByRole(BASE_ROLE);
00460   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00461   test_OpenClose(COMPONENT_NAME_BASE);
00462   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00463 
00464   full_component_name = (OMX_STRING) malloc(OMX_MAX_STRINGNAME_SIZE);
00465   strcpy(full_component_name, COMPONENT_NAME_BASE);
00466   if(selectedType == MP3_TYPE_SEL) {
00467     strcpy(full_component_name+COMPONENT_NAME_BASE_LEN, ".mp3");
00468     if (flagIsMadRequested) {
00469       strcpy(full_component_name+COMPONENT_NAME_BASE_LEN+4, ".mad");
00470     }
00471   } else if (selectedType == VORBIS_TYPE_SEL) {
00472     strcpy(full_component_name+COMPONENT_NAME_BASE_LEN, ".ogg");
00473     if (flagSingleOGGSelected) {
00474       strcpy(full_component_name+COMPONENT_NAME_BASE_LEN+4, ".single");
00475     }
00476   } else if (selectedType == AAC_TYPE_SEL) {   
00477     strcpy(full_component_name+COMPONENT_NAME_BASE_LEN, ".aac");
00478   }
00479 
00480   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00481     DEBUG(DEB_LEV_SIMPLE_SEQ, "Using File Reader\n");
00483     err = OMX_GetHandle(&appPriv->filereaderhandle, FILE_READER, NULL /*appPriv */, &filereadercallbacks);
00484     if(err != OMX_ErrorNone) {
00485       DEBUG(DEB_LEV_ERR, "FileReader Component Not Found\n");
00486       exit(1);
00487     }  
00488   }
00489   
00491   DEBUG(DEB_LEV_SIMPLE_SEQ, "Getting Audio %s Decoder Handle\n",full_component_name);
00492   err = OMX_GetHandle(&appPriv->audiodechandle, full_component_name, NULL /*appPriv */, &audiodeccallbacks);
00493   if(err != OMX_ErrorNone) {
00494     DEBUG(DEB_LEV_ERR, "Audio Decoder Component Not Found\n");
00495     exit(1);
00496   } 
00497   DEBUG(DEFAULT_MESSAGES, "Component %s opened\n", full_component_name);
00498   if (flagPlaybackOn) {
00499     err = OMX_GetHandle(&appPriv->audiosinkhandle, SINK_NAME, NULL , &audiosinkcallbacks);
00500     if(err != OMX_ErrorNone){
00501       DEBUG(DEB_LEV_ERR, "No sink found. Exiting...\n");
00502       exit(1);
00503     }
00504     DEBUG(DEFAULT_MESSAGES, "Getting Handle for Component %s\n", AUDIO_EFFECT);
00505     err = OMX_GetHandle(&appPriv->volumehandle, AUDIO_EFFECT, NULL , &volumecallbacks);
00506     if(err != OMX_ErrorNone){
00507       DEBUG(DEB_LEV_ERR, "No Volume Component found. Exiting...\n");
00508       exit(1);
00509     }
00510 
00511     if((gain >= 0) && (gain <100)) {
00512       err = OMX_GetConfig(appPriv->volumehandle, OMX_IndexConfigAudioVolume, &sVolume);
00513       if(err!=OMX_ErrorNone) {
00514         DEBUG(DEB_LEV_ERR,"Error %08x In OMX_GetConfig 0 \n",err);
00515       }
00516       sVolume.sVolume.nValue = gain;
00517       DEBUG(DEFAULT_MESSAGES, "Setting Gain %d \n", gain);
00518       err = OMX_SetConfig(appPriv->volumehandle, OMX_IndexConfigAudioVolume, &sVolume);
00519       if(err!=OMX_ErrorNone) {
00520         DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig 0 \n",err);
00521       }
00522     }
00523   }
00524 
00525   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00527     err = OMX_GetExtensionIndex(appPriv->filereaderhandle,"OMX.ST.index.param.filereader.inputfilename",&eIndexParamFilename);
00528     if(err != OMX_ErrorNone) {
00529       DEBUG(DEB_LEV_ERR,"\n error in get extension index\n");
00530       exit(1);
00531     } else {
00532       DEBUG(DEB_LEV_SIMPLE_SEQ,"FileName Param index : %x \n",eIndexParamFilename);
00533       temp = malloc(25);
00534       OMX_GetParameter(appPriv->filereaderhandle,eIndexParamFilename,temp);
00535       err = OMX_SetParameter(appPriv->filereaderhandle,eIndexParamFilename,input_file);
00536       if(err != OMX_ErrorNone) {
00537         DEBUG(DEB_LEV_ERR,"\n error in input audio format - exiting\n");
00538         exit(1);
00539       }
00540     }
00541   }
00542 
00543   if (flagSetupTunnel) {
00544     DEBUG(DEB_LEV_SIMPLE_SEQ, "Setting up Tunnel\n");
00545     if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00546       err = OMX_SetupTunnel(appPriv->filereaderhandle, 0, appPriv->audiodechandle, 0);
00547       if(err != OMX_ErrorNone) {
00548         DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
00549         exit(1);
00550       }
00551     }
00552     err = OMX_SetupTunnel(appPriv->audiodechandle, 1, appPriv->volumehandle, 0);
00553     if(err != OMX_ErrorNone) {
00554       DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
00555       exit(1);
00556     }
00557     err = OMX_SetupTunnel(appPriv->volumehandle, 1, appPriv->audiosinkhandle, 0);
00558     if(err != OMX_ErrorNone) {
00559       DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
00560       exit(1);
00561     }
00562     DEBUG(DEB_LEV_SIMPLE_SEQ, "Set up Tunnel Completed\n");
00563   }
00564   
00565   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00567     OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00568   }
00569 
00570   if (flagSetupTunnel) {
00571     DEBUG(DEB_LEV_SIMPLE_SEQ, "Send Command Idle to Audio Dec\n");
00572     /*Send State Change Idle command to Audio Decoder*/
00573     err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00574     if (flagPlaybackOn) {
00575       DEBUG(DEB_LEV_SIMPLE_SEQ, "Send Command Idle to Audio Sink\n");
00576       err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00577       err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00578     }
00579     if( !flagUsingFFMpeg && !flagIsMadUsingFileReader) {
00580       err = OMX_AllocateBuffer(appPriv->audiodechandle, &inBufferAudioDec1, 0, NULL, buffer_in_size);
00581       if(err != OMX_ErrorNone) {
00582         DEBUG(DEB_LEV_ERR, "Unable to allocate buffer\n");
00583         exit(1);
00584       }
00585       err = OMX_AllocateBuffer(appPriv->audiodechandle, &inBufferAudioDec2, 0, NULL, buffer_in_size);
00586       if(err != OMX_ErrorNone) {
00587         DEBUG(DEB_LEV_ERR, "Unable to allocate buffer\n");
00588         exit(1);
00589       }
00590     }
00591   }
00592 
00593   if (!flagSetupTunnel && ( flagUsingFFMpeg || flagIsMadUsingFileReader)) {
00594     outBufferFileRead1 = outBufferFileRead2 = NULL;
00598     err = OMX_AllocateBuffer(appPriv->filereaderhandle, &outBufferFileRead1, 0, NULL, buffer_out_size);
00599     if(err != OMX_ErrorNone) {
00600       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer 1 in file read\n");
00601       exit(1);
00602     }
00603     err = OMX_AllocateBuffer(appPriv->filereaderhandle, &outBufferFileRead2, 0, NULL, buffer_out_size);
00604     if(err != OMX_ErrorNone) {
00605       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer 2 in file read\n");
00606       exit(1);
00607     }
00608   }
00609   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00610     /*Wait for File reader state change to */
00611     tsem_down(appPriv->filereaderEventSem);
00612     DEBUG(DEFAULT_MESSAGES,"File reader idle state \n");
00613   }
00614 
00615   if (flagSetupTunnel) {
00616     tsem_down(appPriv->decoderEventSem);
00617     if (flagPlaybackOn) {
00618       tsem_down(appPriv->volumeEventSem);
00619       tsem_down(appPriv->sinkEventSem);
00620     }
00621   }
00622 
00623   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00624     err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
00625     if(err != OMX_ErrorNone) {
00626       DEBUG(DEB_LEV_ERR,"file reader state executing failed\n");
00627       exit(1);
00628     }
00629     /*Wait for File reader state change to executing*/
00630     tsem_down(appPriv->filereaderEventSem);
00631     DEBUG(DEFAULT_MESSAGES,"File reader executing state \n");
00632 
00633     /*Wait for File Reader Ports Setting Changed Event. Since File Reader Always detect the stream
00634     Always ports setting change event will be received*/
00635     tsem_down(appPriv->filereaderEventSem);
00636     DEBUG(DEFAULT_MESSAGES,"File reader Port Settings Changed event \n");
00637   }
00638 
00639   /*Send State Change Idle command to Audio Decoder*/
00640   if (!flagSetupTunnel) {
00641     err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00642 
00646     if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00647       err = OMX_UseBuffer(appPriv->audiodechandle, &inBufferAudioDec1, 0, NULL, buffer_out_size, outBufferFileRead1->pBuffer);
00648       if(err != OMX_ErrorNone) {
00649         DEBUG(DEB_LEV_ERR, "Unable to use the file read comp allocate buffer\n");
00650         exit(1);
00651       }
00652       err = OMX_UseBuffer(appPriv->audiodechandle, &inBufferAudioDec2, 0, NULL, buffer_out_size, outBufferFileRead2->pBuffer);
00653       if(err != OMX_ErrorNone) {
00654         DEBUG(DEB_LEV_ERR, "Unable to use the file read comp allocate buffer\n");
00655         exit(1);
00656       }
00657     }
00658     else {
00659       err = OMX_AllocateBuffer(appPriv->audiodechandle, &inBufferAudioDec1, 0, NULL, buffer_in_size);
00660       if(err != OMX_ErrorNone) {
00661         DEBUG(DEB_LEV_ERR, "Unable to allocate buffer\n");
00662         exit(1);
00663       }
00664       err = OMX_AllocateBuffer(appPriv->audiodechandle, &inBufferAudioDec2, 0, NULL, buffer_in_size);
00665       if(err != OMX_ErrorNone) {
00666         DEBUG(DEB_LEV_ERR, "Unable to allocate buffer\n");
00667         exit(1);
00668       }
00669     }
00670 
00671     err = OMX_AllocateBuffer(appPriv->audiodechandle, &outBufferAudioDec1, 1, NULL, buffer_out_size);
00672     if(err != OMX_ErrorNone) {
00673       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in audio dec\n");
00674       exit(1);
00675     }
00676     err = OMX_AllocateBuffer(appPriv->audiodechandle, &outBufferAudioDec2, 1, NULL, buffer_out_size);
00677     if(err != OMX_ErrorNone) {
00678       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in audio dec\n");
00679       exit(1);
00680     }
00681     /*Wait for decoder state change to idle*/
00682     tsem_down(appPriv->decoderEventSem);
00683   }
00684 
00685 
00686   if ((flagPlaybackOn) && (!flagSetupTunnel)) {
00687     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00688 
00689     err = OMX_UseBuffer(appPriv->volumehandle, &inBufferVolume1, 0, NULL, buffer_out_size, outBufferAudioDec1->pBuffer);
00690     if(err != OMX_ErrorNone) {
00691       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
00692       exit(1);
00693     }
00694     err = OMX_UseBuffer(appPriv->volumehandle, &inBufferVolume2, 0, NULL, buffer_out_size, outBufferAudioDec2->pBuffer);
00695     if(err != OMX_ErrorNone) {
00696       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
00697       exit(1);
00698     }
00699 
00700     err = OMX_AllocateBuffer(appPriv->volumehandle, &outBufferVolume1, 1, NULL, buffer_out_size);
00701     if(err != OMX_ErrorNone) {
00702       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in volume 1\n");
00703       exit(1);
00704     }
00705     err = OMX_AllocateBuffer(appPriv->volumehandle, &outBufferVolume2, 1, NULL, buffer_out_size);
00706     if(err != OMX_ErrorNone) {
00707       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in volume 2\n");
00708       exit(1);
00709     }
00710 
00711     if (flagPlaybackOn) {
00712       tsem_down(appPriv->volumeEventSem);
00713       DEBUG(DEB_LEV_SIMPLE_SEQ,"volume state idle\n");
00714     }
00715 
00716     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00717 
00718     err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSink1, 0, NULL, buffer_out_size, outBufferVolume1->pBuffer);
00719     if(err != OMX_ErrorNone) {
00720       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
00721       exit(1);
00722     }
00723     err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSink2, 0, NULL, buffer_out_size, outBufferVolume2->pBuffer);
00724     if(err != OMX_ErrorNone) {
00725       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
00726       exit(1);
00727     }
00728     if (flagPlaybackOn) {
00729       tsem_down(appPriv->sinkEventSem);
00730       DEBUG(DEB_LEV_SIMPLE_SEQ,"audio sink state idle\n");
00731     }
00732   }
00733 
00734   err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
00735   if(err != OMX_ErrorNone) {
00736     DEBUG(DEB_LEV_ERR,"audio decoder state executing failed\n");
00737     exit(1);
00738   }
00739   /*Wait for decoder state change to executing*/
00740   tsem_down(appPriv->decoderEventSem);
00741   if (flagPlaybackOn) {
00742     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
00743     if(err != OMX_ErrorNone) {
00744       DEBUG(DEB_LEV_ERR,"volume state executing failed\n");
00745       exit(1);
00746     }
00747     DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for  volume state executing\n");
00748     tsem_down(appPriv->volumeEventSem);
00749 
00750     DEBUG(DEB_LEV_SIMPLE_SEQ,"sending audio sink state executing\n");
00751     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
00752     if(err != OMX_ErrorNone) {
00753       DEBUG(DEB_LEV_ERR,"audio sink state executing failed\n");
00754       exit(1);
00755     }
00756     DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for  audio sink state executing\n");
00757     tsem_down(appPriv->sinkEventSem);
00758     DEBUG(DEB_LEV_SIMPLE_SEQ, "audio sink state executing successful\n");
00759   }
00760   
00761   DEBUG(DEB_LEV_SIMPLE_SEQ,"All Component state changed to Executing\n");
00762   if (!flagSetupTunnel && (flagUsingFFMpeg || flagIsMadUsingFileReader)) {
00763     err = OMX_FillThisBuffer(appPriv->filereaderhandle, outBufferFileRead1);
00764     if(err != OMX_ErrorNone) {
00765       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer File Reader\n", __func__,err);
00766       exit(1);
00767     }
00768     DEBUG(DEB_LEV_PARAMS, "Fill reader second buffer %x\n", (int)outBufferFileRead1);
00769     err = OMX_FillThisBuffer(appPriv->filereaderhandle, outBufferFileRead2);
00770     if(err != OMX_ErrorNone) {
00771       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer File Reader\n", __func__,err);
00772       exit(1);
00773     }
00774   }
00775 
00776   if (!flagSetupTunnel && flagPlaybackOn) {
00777     err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume1);
00778     if(err != OMX_ErrorNone) {
00779       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
00780       exit(1);
00781     }
00782     DEBUG(DEB_LEV_PARAMS, "Fill decoder second buffer %x\n", (int)outBufferVolume2);
00783     err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume2);
00784     if(err != OMX_ErrorNone) {
00785       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
00786       exit(1);
00787     }
00788   }
00789 
00790   if(!flagUsingFFMpeg && !flagIsMadUsingFileReader) {
00791     data_read = fread(inBufferAudioDec1->pBuffer, 1, buffer_in_size, fd);
00792     inBufferAudioDec1->nFilledLen = data_read;
00793     inBufferAudioDec1->nOffset = 0;
00794 
00795     data_read = fread(inBufferAudioDec2->pBuffer, 1, buffer_in_size, fd);
00796     inBufferAudioDec2->nFilledLen = data_read;
00797     inBufferAudioDec2->nOffset = 0;
00798 
00799     DEBUG(DEB_LEV_PARAMS, "Empty first  buffer %x\n", (int)inBufferAudioDec1);
00800     err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec1);
00801     DEBUG(DEB_LEV_PARAMS, "Empty second buffer %x\n", (int)inBufferAudioDec2);
00802     err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec2);
00803   }
00804   /* Call FillThisBuffer now, to ensure that first two input buffers has already been sent to the component*/
00805   if (!flagSetupTunnel) {
00806     err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec1);
00807     if(err != OMX_ErrorNone) {
00808       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
00809       exit(1);
00810     }
00811     DEBUG(DEB_LEV_PARAMS, "Fill decoder second buffer %x\n", (int)outBufferAudioDec2);
00812     err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec2);
00813     if(err != OMX_ErrorNone) {
00814       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
00815       exit(1);
00816     }
00817   }
00818 
00819   DEBUG(DEFAULT_MESSAGES,"Waiting for  EOS = %d\n",appPriv->eofSem->semval);
00820 
00821   tsem_down(appPriv->eofSem);
00822 
00823   DEBUG(DEFAULT_MESSAGES,"Received EOS \n");
00824   /*Send Idle Command to all components*/
00825   DEBUG(DEFAULT_MESSAGES, "The execution of the decoding process is terminated\n");
00826   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00827     err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00828   }
00829   err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00830   if (flagPlaybackOn) {
00831     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00832     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00833   }  
00834   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00835     tsem_down(appPriv->filereaderEventSem);
00836     DEBUG(DEFAULT_MESSAGES,"File reader idle state \n");
00837   }
00838   tsem_down(appPriv->decoderEventSem);
00839   if (flagPlaybackOn) {
00840     tsem_down(appPriv->volumeEventSem);
00841     tsem_down(appPriv->sinkEventSem);
00842   }
00843 
00844   DEBUG(DEFAULT_MESSAGES, "All component Transitioned to Idle\n");
00845   /*Send Loaded Command to all components*/
00846   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00847     err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
00848   }
00849   err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
00850   if (flagPlaybackOn) {
00851     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
00852     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
00853   }
00854 
00855   DEBUG(DEFAULT_MESSAGES, "Audio dec to loaded\n");
00856 
00857   /*Free buffers is components are not tunnelled*/
00858   if (!flagSetupTunnel || (!flagUsingFFMpeg && !flagIsMadUsingFileReader )) {
00859     err = OMX_FreeBuffer(appPriv->audiodechandle, 0, inBufferAudioDec1);
00860     err = OMX_FreeBuffer(appPriv->audiodechandle, 0, inBufferAudioDec2);
00861   }
00862   DEBUG(DEB_LEV_PARAMS, "Free Audio dec output ports\n");
00863   if (!flagSetupTunnel) {
00864     err = OMX_FreeBuffer(appPriv->audiodechandle, 1, outBufferAudioDec1);
00865     err = OMX_FreeBuffer(appPriv->audiodechandle, 1, outBufferAudioDec2);
00866   }
00867 
00868   if (!flagSetupTunnel && (flagUsingFFMpeg || flagIsMadUsingFileReader)) {
00869     err = OMX_FreeBuffer(appPriv->filereaderhandle, 0, outBufferFileRead1);
00870     err = OMX_FreeBuffer(appPriv->filereaderhandle, 0, outBufferFileRead2);
00871   }
00872 
00873   if ((flagPlaybackOn) && (!flagSetupTunnel)) {
00874     err = OMX_FreeBuffer(appPriv->volumehandle, 0, inBufferVolume1);
00875     err = OMX_FreeBuffer(appPriv->volumehandle, 0, inBufferVolume2);
00876     err = OMX_FreeBuffer(appPriv->volumehandle, 1, outBufferVolume1);
00877     err = OMX_FreeBuffer(appPriv->volumehandle, 1, outBufferVolume2);
00878 
00879     err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSink1);
00880     err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSink2);
00881   }
00882 
00883   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00884     tsem_down(appPriv->filereaderEventSem);
00885     DEBUG(DEFAULT_MESSAGES,"File reader loaded state \n");
00886   }
00887   tsem_down(appPriv->decoderEventSem);
00888   if (flagPlaybackOn) {
00889     tsem_down(appPriv->volumeEventSem);
00890     tsem_down(appPriv->sinkEventSem);
00891   }
00892 
00893 
00894   DEBUG(DEFAULT_MESSAGES, "All components released\n");
00895 
00897   OMX_FreeHandle(appPriv->audiodechandle);
00898   DEBUG(DEB_LEV_SIMPLE_SEQ, "audiodec dec freed\n");
00899   
00900   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00901     OMX_FreeHandle(appPriv->filereaderhandle);
00902     DEBUG(DEB_LEV_SIMPLE_SEQ, "filereader freed\n");
00903   }
00904 
00905   if (flagPlaybackOn) {
00906     OMX_FreeHandle(appPriv->volumehandle);
00907     DEBUG(DEB_LEV_SIMPLE_SEQ, "volume component freed\n");
00908     OMX_FreeHandle(appPriv->audiosinkhandle);
00909     DEBUG(DEB_LEV_SIMPLE_SEQ, "audiosink freed\n");
00910   }
00911 
00912   OMX_Deinit();
00913 
00914   DEBUG(DEB_LEV_SIMPLE_SEQ, "All components freed. Closing...\n");
00915 
00916   free(appPriv->filereaderEventSem);
00917   appPriv->filereaderEventSem = NULL;
00918 
00919   free(appPriv->decoderEventSem);
00920   appPriv->decoderEventSem = NULL;
00921   if (flagPlaybackOn) {
00922     free(appPriv->volumeEventSem);
00923     appPriv->volumeEventSem = NULL;
00924 
00925     free(appPriv->sinkEventSem);
00926     appPriv->sinkEventSem = NULL;
00927   }
00928 
00929   free(appPriv->eofSem);
00930   appPriv->eofSem = NULL;
00931   free(appPriv);
00932   appPriv = NULL;
00933   if (flagOutputReceived) {
00934     fclose(outfile);
00935   }
00936 
00937   if(!flagUsingFFMpeg && !flagIsMadUsingFileReader) {
00938     if(fclose(fd) != 0) {
00939       DEBUG(DEB_LEV_ERR,"Error in closing input file stream\n");
00940       exit(1);
00941     }
00942     else {
00943       DEBUG(DEB_LEV_SIMPLE_SEQ,"Succees in closing input file stream\n");
00944     }
00945   }
00946 
00947   free(full_component_name);
00948   free(input_file);
00949   free(output_file);
00950   free(temp);
00951 
00952   return 0;
00953 }  
00954 
00955 /* Callbacks implementation */
00956 
00957 OMX_ERRORTYPE filereaderEventHandler(
00958   OMX_OUT OMX_HANDLETYPE hComponent,
00959   OMX_OUT OMX_PTR pAppData,
00960   OMX_OUT OMX_EVENTTYPE eEvent,
00961   OMX_OUT OMX_U32 Data1,
00962   OMX_OUT OMX_U32 Data2,
00963   OMX_OUT OMX_PTR pEventData)
00964 {
00965   OMX_PTR pExtraData;
00966   OMX_INDEXTYPE eIndexExtraData;
00967   OMX_ERRORTYPE err;
00968   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
00969 
00970   if(eEvent == OMX_EventCmdComplete) {
00971     if (Data1 == OMX_CommandStateSet) {
00972       DEBUG(DEB_LEV_SIMPLE_SEQ, "File Reader State changed in ");
00973       switch ((int)Data2) {
00974       case OMX_StateInvalid:
00975         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
00976         break;
00977       case OMX_StateLoaded:
00978         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
00979         break;
00980       case OMX_StateIdle:
00981         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
00982         break;
00983       case OMX_StateExecuting:
00984         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
00985         break;
00986       case OMX_StatePause:
00987         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
00988         break;
00989       case OMX_StateWaitForResources:
00990         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
00991         break;
00992       }
00993       tsem_up(appPriv->filereaderEventSem);
00994     } else if (Data1 == OMX_CommandPortEnable){
00995       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
00996       tsem_up(appPriv->filereaderEventSem);
00997     } else if (Data1 == OMX_CommandPortDisable){
00998       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
00999       tsem_up(appPriv->filereaderEventSem);
01000     } else {
01001       DEBUG(DEB_LEV_SIMPLE_SEQ,"In %s Received Event Event=%d Data1=%d,Data2=%d\n",__func__,eEvent,(int)Data1,(int)Data2);
01002     }
01003   } else if(eEvent == OMX_EventPortSettingsChanged) {
01004     DEBUG(DEB_LEV_SIMPLE_SEQ,"File reader Port Setting Changed event\n");
01005     if(flagUsingFFMpeg) {
01006       err = OMX_GetExtensionIndex(appPriv->audiodechandle,"OMX.ST.index.config.audioextradata",&eIndexExtraData);
01007       if(err != OMX_ErrorNone) {
01008         DEBUG(DEB_LEV_ERR,"\n error in get extension index\n");
01009         exit(1);
01010       } else {
01011         pExtraData = malloc(extradata_size);
01012         err = OMX_GetConfig(appPriv->filereaderhandle, eIndexExtraData, pExtraData);
01013         if(err != OMX_ErrorNone) {
01014           DEBUG(DEB_LEV_ERR,"\n file reader Get Param Failed error =%08x index=%08x\n",err,eIndexExtraData);
01015           exit(1);
01016         }
01017         DEBUG(DEB_LEV_SIMPLE_SEQ,"Setting ExtraData\n");
01018         err = OMX_SetConfig(appPriv->audiodechandle, eIndexExtraData, pExtraData);
01019         if(err != OMX_ErrorNone) {
01020           DEBUG(DEB_LEV_ERR,"\n audio decoder Set Config Failed error=%08x\n",err);
01021           exit(1);
01022         }
01023         free(pExtraData);
01024       }
01025     }
01026     /*Signal Port Setting Changed*/
01027     tsem_up(appPriv->filereaderEventSem);
01028   } else if(eEvent == OMX_EventPortFormatDetected) {
01029     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Port Format Detected %x\n", __func__,(int)Data1);
01030   } else if(eEvent == OMX_EventBufferFlag) {
01031     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
01032     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
01033       tsem_up(appPriv->eofSem);
01034     }
01035   } else {
01036     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01037     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01038   }
01039   return OMX_ErrorNone;
01040 }
01041 
01042 OMX_ERRORTYPE filereaderFillBufferDone(
01043   OMX_OUT OMX_HANDLETYPE hComponent,
01044   OMX_OUT OMX_PTR pAppData,
01045   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01046 {
01047   OMX_ERRORTYPE err;
01048   /* Output data to audio decoder */
01049 
01050   if(pBuffer != NULL){
01051     if(!bEOS) {
01052       if(inBufferAudioDec1->pBuffer == pBuffer->pBuffer) {
01053         inBufferAudioDec1->nFilledLen = pBuffer->nFilledLen;
01054         err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec1);
01055       } else {
01056         inBufferAudioDec2->nFilledLen = pBuffer->nFilledLen;
01057         err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec2);
01058       }
01059       if(err != OMX_ErrorNone) {
01060         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01061       }
01062       if(pBuffer->nFlags==OMX_BUFFERFLAG_EOS) {
01063         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Calling Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
01064         bEOS=OMX_TRUE;
01065       }
01066     } else {
01067       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
01068     }
01069   } else {
01070     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01071   }
01072   return OMX_ErrorNone;
01073 }
01074 
01075 OMX_ERRORTYPE audiodecEventHandler(
01076   OMX_OUT OMX_HANDLETYPE hComponent,
01077   OMX_OUT OMX_PTR pAppData,
01078   OMX_OUT OMX_EVENTTYPE eEvent,
01079   OMX_OUT OMX_U32 Data1,
01080   OMX_OUT OMX_U32 Data2,
01081   OMX_OUT OMX_PTR pEventData)
01082 {
01083   OMX_ERRORTYPE err;
01084   OMX_PARAM_PORTDEFINITIONTYPE param;
01085   OMX_AUDIO_PARAM_PCMMODETYPE pcmParam;
01086   
01087   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
01088   if(eEvent == OMX_EventCmdComplete) {
01089     if (Data1 == OMX_CommandStateSet) {
01090       DEBUG(DEB_LEV_SIMPLE_SEQ/*SIMPLE_SEQ*/, "Audio Decoder State changed in ");
01091       switch ((int)Data2) {
01092       case OMX_StateInvalid:
01093         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
01094         break;
01095       case OMX_StateLoaded:
01096         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
01097         break;
01098       case OMX_StateIdle:
01099         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01100         break;
01101       case OMX_StateExecuting:
01102         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01103         break;
01104       case OMX_StatePause:
01105         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01106         break;
01107       case OMX_StateWaitForResources:
01108         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01109         break;
01110       }
01111       tsem_up(appPriv->decoderEventSem);
01112     } else if (Data1 == OMX_CommandPortEnable){
01113       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
01114       tsem_up(appPriv->decoderEventSem);
01115     } else if (Data1 == OMX_CommandPortDisable){
01116       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
01117       tsem_up(appPriv->decoderEventSem);
01118     } 
01119   } else if(eEvent == OMX_EventPortSettingsChanged) {
01120     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Settings Changed Event\n", __func__);
01121     if (Data2 == 1) {
01122       param.nPortIndex = 1;
01123       setHeader(&param, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
01124       err = OMX_GetParameter(appPriv->audiodechandle,OMX_IndexParamPortDefinition, &param);
01125       /*Get Port parameters*/
01126       pcmParam.nPortIndex=1;
01127       setHeader(&pcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
01128       err = OMX_GetParameter(appPriv->audiodechandle, OMX_IndexParamAudioPcm, &pcmParam);
01129 
01130       /*Disable Audio Sink Port and Set Parameter in Non-tunneled Case*/
01131       if ((flagPlaybackOn) && (!flagSetupTunnel)) {
01132 
01133         err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortDisable, 0, NULL);
01134         if(err != OMX_ErrorNone) {
01135           DEBUG(DEB_LEV_ERR,"alsa sink port disable failed\n");
01136           exit(1);
01137         }
01138 
01139         err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSink1);
01140         err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSink2);
01141 
01142         /*Wait for sink Ports Disable Event*/
01143         tsem_down(appPriv->sinkEventSem);
01144 
01145         pcmParam.nPortIndex=0;
01146         err = OMX_SetParameter(appPriv->audiosinkhandle, OMX_IndexParamAudioPcm, &pcmParam);
01147         if(err!=OMX_ErrorNone) {
01148           DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetParameter 0 \n",err);
01149         }
01150 
01151         err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortEnable, 0, NULL);
01152         if(err != OMX_ErrorNone) {
01153           DEBUG(DEB_LEV_ERR,"alsa sink port disable failed\n");
01154           exit(1);
01155         }
01156 
01157         err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSink1, 0, NULL, buffer_out_size, outBufferVolume1->pBuffer);
01158         if(err != OMX_ErrorNone) {
01159           DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01160           exit(1);
01161         }
01162         err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSink2, 0, NULL, buffer_out_size, outBufferVolume2->pBuffer);
01163         if(err != OMX_ErrorNone) {
01164           DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01165           exit(1);
01166         }
01167 
01168         /*Wait for sink Ports Enable Event*/
01169         tsem_down(appPriv->sinkEventSem);
01170         DEBUG(DEB_LEV_SIMPLE_SEQ,"audio sink port enabled\n");
01171       } else if (flagPlaybackOn && flagSetupTunnel) { /*Disable Volume Component and Audio Sink Port,Set Parameter in Tunneled Case*/
01172 
01173         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Volume Component Port Disabling\n", __func__);
01174 
01175         err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortDisable, 1, NULL);
01176         if(err != OMX_ErrorNone) {
01177           DEBUG(DEB_LEV_ERR,"Volume Component port disable failed\n");
01178           exit(1);
01179         }
01180 
01181         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Port Disabling\n", __func__);
01182         err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortDisable, 0, NULL);
01183         if(err != OMX_ErrorNone) {
01184           DEBUG(DEB_LEV_ERR,"alas sink port disable failed\n");
01185           exit(1);
01186         }
01187 
01188         /*Wait for Ports Disable Events*/
01189         tsem_down(appPriv->sinkEventSem);
01190         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Port Disabled\n", __func__);
01191         tsem_down(appPriv->volumeEventSem);
01192         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Volume Component Port Disabled\n", __func__);
01193 
01194         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Setting Parameters\n", __func__);
01195 
01196         pcmParam.nPortIndex=0;
01197         err = OMX_SetParameter(appPriv->audiosinkhandle, OMX_IndexParamAudioPcm, &pcmParam);
01198         if(err!=OMX_ErrorNone) {
01199           DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetParameter 0 \n",err);
01200         }
01201 
01202         err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortEnable, 1, NULL);
01203         err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortEnable, 0, NULL);
01204         if(err != OMX_ErrorNone) {
01205           DEBUG(DEB_LEV_ERR,"audio sink port enable failed\n");
01206           exit(1);
01207         }
01208 
01209         /*Wait for Ports Enable Events*/
01210         tsem_down(appPriv->volumeEventSem);
01211         tsem_down(appPriv->sinkEventSem);
01212         DEBUG(DEB_LEV_SIMPLE_SEQ,"audio sink port enabled\n");
01213       }
01214      
01215     } else if (Data2 == 0) {
01216       /*Get Port parameters*/
01217       param.nPortIndex = 0;
01218       setHeader(&param, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
01219       err = OMX_GetParameter(appPriv->audiodechandle,OMX_IndexParamPortDefinition, &param);
01220     }
01221   } else if(eEvent == OMX_EventBufferFlag) {
01222     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
01223     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
01224       tsem_up(appPriv->eofSem);
01225     }
01226   } else {
01227     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01228     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01229   }
01230   
01231   return OMX_ErrorNone;
01232 }
01233 
01234 OMX_ERRORTYPE audiodecEmptyBufferDone(
01235   OMX_OUT OMX_HANDLETYPE hComponent,
01236   OMX_OUT OMX_PTR pAppData,
01237   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01238 {
01239   OMX_ERRORTYPE err;
01240   int data_read;
01241   static int iBufferDropped=0;
01242   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
01243 
01244   if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
01245     if(pBuffer != NULL){
01246       if(!bEOS) {
01247         if(outBufferFileRead1->pBuffer == pBuffer->pBuffer) {
01248           outBufferFileRead1->nFilledLen=0;
01249           err = OMX_FillThisBuffer(appPriv->filereaderhandle, outBufferFileRead1);
01250         } else {
01251           outBufferFileRead2->nFilledLen=0;
01252           err = OMX_FillThisBuffer(appPriv->filereaderhandle, outBufferFileRead2);
01253         }
01254         if(err != OMX_ErrorNone) {
01255           DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01256         }
01257       } else {
01258         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
01259         iBufferDropped++;
01260         if(iBufferDropped==2) {
01261           tsem_up(appPriv->eofSem);
01262         }
01263       }
01264     } else {
01265       if(!bEOS) {
01266         DEBUG(DEB_LEV_SIMPLE_SEQ,"It is here EOS = %d\n",appPriv->eofSem->semval);
01267         tsem_up(appPriv->eofSem);
01268       }
01269       DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01270     }
01271   } else {
01272 
01273     data_read = fread(pBuffer->pBuffer, 1, buffer_in_size, fd);
01274     pBuffer->nFilledLen = data_read;
01275     pBuffer->nOffset = 0;
01276     if (data_read <= 0) {
01277       DEBUG(DEB_LEV_SIMPLE_SEQ, "In the %s no more input data available\n", __func__);
01278       iBufferDropped++;
01279       if(iBufferDropped>=2) {
01280         tsem_up(appPriv->eofSem);
01281         return OMX_ErrorNone;
01282       }
01283       pBuffer->nFilledLen=0;
01284       pBuffer->nFlags = OMX_BUFFERFLAG_EOS;
01285       bEOS=OMX_TRUE;
01286       err = OMX_EmptyThisBuffer(hComponent, pBuffer);
01287       return OMX_ErrorNone;
01288     }
01289     pBuffer->nFilledLen = data_read;
01290     if(!bEOS) {
01291       DEBUG(DEB_LEV_FULL_SEQ, "Empty buffer %x\n", (int)pBuffer);
01292       err = OMX_EmptyThisBuffer(hComponent, pBuffer);
01293     } else {
01294       DEBUG(DEB_LEV_FULL_SEQ, "In %s Dropping Empty This buffer to Audio Dec\n", __func__);
01295     }
01296   }
01297 
01298   return OMX_ErrorNone;
01299 }
01300 
01301 OMX_ERRORTYPE audiodecFillBufferDone(
01302   OMX_OUT OMX_HANDLETYPE hComponent,
01303   OMX_OUT OMX_PTR pAppData,
01304   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01305 {
01306   OMX_ERRORTYPE err;
01307   int i;
01308   DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__);
01309   /* Output data to alsa sink */
01310   if(pBuffer != NULL){
01311     if (pBuffer->nFilledLen == 0) {
01312       DEBUG(DEB_LEV_ERR, "Ouch! In %s: had 0 data size in output buffer...\n", __func__);
01313       return OMX_ErrorNone;
01314     }
01315     if ((!flagOutputReceived) && (!flagPlaybackOn) && (flagDirect)) {
01316       for(i = 0; i<pBuffer->nFilledLen; i++){
01317         putchar(*(char*)(pBuffer->pBuffer + i));
01318       }
01319       pBuffer->nFilledLen = 0;
01320       err = OMX_FillThisBuffer(hComponent, pBuffer);
01321       if(err != OMX_ErrorNone) {
01322         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01323       }
01324     } else if ((flagOutputReceived) && (!flagPlaybackOn)) {
01325       if(pBuffer->nFilledLen > 0) {
01326         fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfile);
01327       }
01328       pBuffer->nFilledLen = 0;
01329       err = OMX_FillThisBuffer(hComponent, pBuffer);
01330       if(err != OMX_ErrorNone) {
01331         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01332       }
01333     } else if ((!flagSetupTunnel) && (flagPlaybackOn))  { //playback on, redirect to alsa sink, if it is not tunneled
01334       if(inBufferVolume1->pBuffer == pBuffer->pBuffer) {
01335         inBufferVolume1->nFilledLen = pBuffer->nFilledLen;
01336         err = OMX_EmptyThisBuffer(appPriv->volumehandle, inBufferVolume1);
01337       } else {
01338         inBufferVolume2->nFilledLen = pBuffer->nFilledLen;
01339         err = OMX_EmptyThisBuffer(appPriv->volumehandle, inBufferVolume2);
01340       }
01341       if(err != OMX_ErrorNone) {
01342         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling EmptyThisBuffer\n", __func__,err);
01343       }
01344     }
01345   } else {
01346     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01347   }
01348   return OMX_ErrorNone;
01349 }
01350 
01351 OMX_ERRORTYPE volumeEventHandler(
01352   OMX_OUT OMX_HANDLETYPE hComponent,
01353   OMX_OUT OMX_PTR pAppData,
01354   OMX_OUT OMX_EVENTTYPE eEvent,
01355   OMX_OUT OMX_U32 Data1,
01356   OMX_OUT OMX_U32 Data2,
01357   OMX_OUT OMX_PTR pEventData)
01358 {
01359   
01360   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
01361   if(eEvent == OMX_EventCmdComplete) {
01362     if (Data1 == OMX_CommandStateSet) {
01363       DEBUG(DEB_LEV_SIMPLE_SEQ/*SIMPLE_SEQ*/, "Audio Decoder State changed in ");
01364       switch ((int)Data2) {
01365       case OMX_StateInvalid:
01366         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
01367         break;
01368       case OMX_StateLoaded:
01369         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
01370         break;
01371       case OMX_StateIdle:
01372         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01373         break;
01374       case OMX_StateExecuting:
01375         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01376         break;
01377       case OMX_StatePause:
01378         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01379         break;
01380       case OMX_StateWaitForResources:
01381         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01382         break;
01383       }
01384       tsem_up(appPriv->volumeEventSem);
01385     } else  if (Data1 == OMX_CommandPortEnable){
01386       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
01387       tsem_up(appPriv->volumeEventSem);
01388     } else if (Data1 == OMX_CommandPortDisable){
01389       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
01390       tsem_up(appPriv->volumeEventSem);
01391     } 
01392   } else if(eEvent == OMX_EventBufferFlag) {
01393     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
01394     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
01395       tsem_up(appPriv->eofSem);
01396     }
01397   } else {
01398     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01399     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01400   }
01401   
01402   return OMX_ErrorNone;
01403 }
01404 
01405 OMX_ERRORTYPE volumeEmptyBufferDone(
01406   OMX_OUT OMX_HANDLETYPE hComponent,
01407   OMX_OUT OMX_PTR pAppData,
01408   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01409 {
01410   OMX_ERRORTYPE err;
01411   static int iBufferDropped=0;
01412   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
01413 
01414   if(pBuffer != NULL){
01415     if(!bEOS) {
01416       if(outBufferAudioDec1->pBuffer == pBuffer->pBuffer) {
01417         outBufferAudioDec1->nFilledLen=0;
01418         err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec1);
01419       } else {
01420         outBufferAudioDec2->nFilledLen=0;
01421         err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec2);
01422       }
01423       if(err != OMX_ErrorNone) {
01424         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01425       }
01426     } else {
01427       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
01428       iBufferDropped++;
01429       if(iBufferDropped==2) {
01430         tsem_up(appPriv->eofSem);
01431       }
01432     }
01433   } else {
01434     if(!bEOS) {
01435       DEBUG(DEFAULT_MESSAGES,"It is here EOS = %d\n",appPriv->eofSem->semval);
01436       tsem_up(appPriv->eofSem);
01437     }
01438     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01439   }
01440   return OMX_ErrorNone;
01441 }
01442 
01443 OMX_ERRORTYPE volumeFillBufferDone(
01444   OMX_OUT OMX_HANDLETYPE hComponent,
01445   OMX_OUT OMX_PTR pAppData,
01446   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01447 {
01448   OMX_ERRORTYPE err;
01449   int i;
01450   static int volCompBufferDropped=0;
01451   DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__);
01452   /* Output data to alsa sink */
01453   if(pBuffer != NULL){
01454     if (pBuffer->nFilledLen == 0) {
01455       DEBUG(DEB_LEV_ERR, "Ouch! In %s: had 0 data size in output buffer...\n", __func__);
01456       return OMX_ErrorNone;
01457     }
01458     if ((!flagOutputReceived) && (!flagPlaybackOn) && (flagDirect)) {
01459       for(i = 0; i<pBuffer->nFilledLen; i++){
01460         putchar(*(char*)(pBuffer->pBuffer + i));
01461       }
01462       pBuffer->nFilledLen = 0;
01463       err = OMX_FillThisBuffer(hComponent, pBuffer);
01464       if(err != OMX_ErrorNone) {
01465         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01466       }
01467     } else if ((flagOutputReceived) && (!flagPlaybackOn)) {
01468       if(pBuffer->nFilledLen > 0) {
01469         fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfile);
01470       }
01471       pBuffer->nFilledLen = 0;
01472       err = OMX_FillThisBuffer(hComponent, pBuffer);
01473       if(err != OMX_ErrorNone) {
01474         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01475       }
01476     } else if ((!flagSetupTunnel) && (flagPlaybackOn))  { //playback on, redirect to alsa sink, if it is not tunneled
01477       if(!bEOS) {
01478         if(inBufferSink1->pBuffer == pBuffer->pBuffer) {
01479           inBufferSink1->nFilledLen = pBuffer->nFilledLen;
01480           err = OMX_EmptyThisBuffer(appPriv->audiosinkhandle, inBufferSink1);
01481         } else {
01482           inBufferSink2->nFilledLen = pBuffer->nFilledLen;
01483           err = OMX_EmptyThisBuffer(appPriv->audiosinkhandle, inBufferSink2);
01484         }
01485         if(err != OMX_ErrorNone) {
01486           DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling EmptyThisBuffer\n", __func__,err);
01487         }
01488       } else {
01489         DEBUG(DEFAULT_MESSAGES,"In %s EOS reached\n",__func__);
01490         volCompBufferDropped++;
01491         if(volCompBufferDropped==2) {
01492           tsem_up(appPriv->eofSem);
01493         }
01494       }
01495 
01496     }
01497   } else {
01498     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01499   }
01500   return OMX_ErrorNone;
01501 }
01502 
01503 
01504 OMX_ERRORTYPE audiosinkEventHandler(
01505   OMX_OUT OMX_HANDLETYPE hComponent,
01506   OMX_OUT OMX_PTR pAppData,
01507   OMX_OUT OMX_EVENTTYPE eEvent,
01508   OMX_OUT OMX_U32 Data1,
01509   OMX_OUT OMX_U32 Data2,
01510   OMX_OUT OMX_PTR pEventData) {
01511   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
01512   if (Data1 == OMX_CommandStateSet) {
01513     DEBUG(DEB_LEV_SIMPLE_SEQ, "Audio Sink State changed in ");
01514     switch ((int)Data2) {
01515     case OMX_StateInvalid:
01516       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
01517       break;
01518     case OMX_StateLoaded:
01519       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
01520       break;
01521     case OMX_StateIdle:
01522       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01523       break;
01524     case OMX_StateExecuting:
01525       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01526       break;
01527     case OMX_StatePause:
01528       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01529       break;
01530     case OMX_StateWaitForResources:
01531       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01532       break;
01533     }
01534     tsem_up(appPriv->sinkEventSem);
01535   } else if (Data1 == OMX_CommandPortEnable){
01536     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
01537     tsem_up(appPriv->sinkEventSem);
01538   } else if (Data1 == OMX_CommandPortDisable){
01539     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
01540     tsem_up(appPriv->sinkEventSem);
01541   } else {
01542     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01543     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01544   }
01545   
01546   return OMX_ErrorNone;
01547 }
01548 
01549 OMX_ERRORTYPE audiosinkEmptyBufferDone(
01550   OMX_OUT OMX_HANDLETYPE hComponent,
01551   OMX_OUT OMX_PTR pAppData,
01552   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01553 {
01554   OMX_ERRORTYPE err;
01555   static int alsaSinkBufferDropped=0;
01556   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
01557 
01558   DEBUG(DEB_LEV_PARAMS, "Empty buffer %x\n", (int)pBuffer);
01559   if(!bEOS) {
01560     if(outBufferVolume1->pBuffer == pBuffer->pBuffer) {
01561       outBufferVolume1->nFilledLen=0;
01562       err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume1);
01563     } else {
01564       outBufferVolume2->nFilledLen=0;
01565       err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume2);
01566     }
01567     if(err != OMX_ErrorNone) {
01568       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01569     }
01570   } else {
01571     DEBUG(DEFAULT_MESSAGES,"In %s EOS reached\n",__func__);
01572     alsaSinkBufferDropped++;
01573     if(alsaSinkBufferDropped==2) {
01574       tsem_up(appPriv->eofSem);
01575     }
01576   }
01577 
01578   return OMX_ErrorNone;
01579 }
01580