omxaudiodectest.c

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

Generated for OpenMAX Bellagio rel. 0.9.0 by  doxygen 1.5.1
SourceForge.net Logo