omxparsertest.c

Go to the documentation of this file.
00001 
00039 #include "omxparsertest.h"
00040 
00041 #define MPEG4_TYPE_SEL            1
00042 #define AVC_TYPE_SEL              2
00043 #define VIDEO_COMPONENT_NAME_BASE "OMX.st.video_decoder"
00044 #define AUDIO_COMPONENT_NAME_BASE "OMX.st.audio_decoder" 
00045 #define VIDEO_BASE_ROLE           "video_decoder.avc"
00046 #define AUDIO_BASE_ROLE           "audio_decoder.mp3"
00047 #define VIDEO_DEC_MPEG4_ROLE      "video_decoder.mpeg4"
00048 #define VIDEO_DEC_H264_ROLE       "video_decoder.avc"
00049 #define AUDIO_DEC_MP3_ROLE        "audio_decoder.mp3"
00050 #define AUDIO_DEC_AAC_ROLE        "audio_decoder.aac"
00051 #define VIDEO_SINK                "OMX.st.fbdev.fbdev_sink"
00052 #define COLOR_CONV                "OMX.st.video_colorconv.ffmpeg"
00053 #define AUDIO_SINK                "OMX.st.alsa.alsasink"
00054 #define AUDIO_EFFECT              "OMX.st.volume.component"
00055 #define PARSER_3GP                "OMX.st.parser.3gp"
00056 #define CLOCK_SRC                 "OMX.st.clocksrc"
00057 #define COMPONENT_NAME_BASE_LEN   20
00058 #define extradata_size            1024
00059 #define VIDEO_PORT_INDEX          0  /* video port index on clock component */
00060 #define AUDIO_PORT_INDEX          1  /* audio port index on clock component */
00061 #define PARSER_PORT_INDEX         2  /* parser port index on clock component */
00062 #define CLIENT_CLOCK_PORT_INDEX   1  /* clock port index on sink (Audio/Video) component */
00063 #define PARSER_CLOCK_PORT_INDEX   2  /* clock port index on parser component */
00064 
00065 OMX_COLOR_FORMATTYPE COLOR_CONV_OUT_RGB_FORMAT = OMX_COLOR_Format24bitRGB888;
00066 
00067 OMX_BUFFERHEADERTYPE *outBufferParseVideo[2], *outBufferParseAudio[2];
00068 OMX_BUFFERHEADERTYPE *inBufferVideoDec[2], *outBufferVideoDec[2];
00069 OMX_BUFFERHEADERTYPE *inBufferAudioDec[2],*outBufferAudioDec[2];
00071 OMX_BUFFERHEADERTYPE *inBufferColorconv[2], *outBufferColorconv[2];
00072 OMX_BUFFERHEADERTYPE *inBufferSinkVideo[2];
00073 /* used with volume control if selected */
00074 OMX_BUFFERHEADERTYPE *inBufferVolume[2], *outBufferVolume[2];
00075 OMX_BUFFERHEADERTYPE *inBufferSinkAudio[2];
00076 int buffer_in_size = BUFFER_IN_SIZE; 
00077 int buffer_out_size = BUFFER_OUT_SIZE;
00078 static OMX_BOOL bEOS=OMX_FALSE;
00079 
00080 static OMX_PARAM_PORTDEFINITIONTYPE paramPortVideo, paramPortAudio;
00081 OMX_PARAM_PORTDEFINITIONTYPE decparamPortVideo;
00082 OMX_PARAM_PORTDEFINITIONTYPE decparamPortAudio;
00083 
00084 OMX_CALLBACKTYPE videodeccallbacks = { 
00085   .EventHandler = videodecEventHandler,
00086   .EmptyBufferDone = videodecEmptyBufferDone,
00087   .FillBufferDone = videodecFillBufferDone
00088 };
00089 
00090 OMX_CALLBACKTYPE colorconv_callbacks = { 
00091   .EventHandler = colorconvEventHandler,
00092   .EmptyBufferDone = colorconvEmptyBufferDone,
00093   .FillBufferDone = colorconvFillBufferDone
00094 };
00095 
00096 OMX_CALLBACKTYPE fbdev_sink_callbacks = { 
00097   .EventHandler = fb_sinkEventHandler,
00098   .EmptyBufferDone = fb_sinkEmptyBufferDone,
00099   .FillBufferDone = NULL
00100 };
00101 
00102 OMX_CALLBACKTYPE parser3gpcallbacks = { 
00103   .EventHandler    = parser3gpEventHandler,
00104   .EmptyBufferDone = NULL,
00105   .FillBufferDone  = parser3gpFillBufferDone
00106 };
00107 
00108 OMX_CALLBACKTYPE clocksrccallbacks = {
00109   .EventHandler    = clocksrcEventHandler,
00110   .EmptyBufferDone = NULL,
00111   .FillBufferDone  = clocksrcFillBufferDone
00112 };
00113 
00114 OMX_CALLBACKTYPE audiodeccallbacks = {
00115   .EventHandler    = audiodecEventHandler,
00116   .EmptyBufferDone = audiodecEmptyBufferDone,
00117   .FillBufferDone  = audiodecFillBufferDone
00118 };
00119 
00120 OMX_CALLBACKTYPE audiosinkcallbacks = {
00121   .EventHandler    = audiosinkEventHandler,
00122   .EmptyBufferDone = audiosinkEmptyBufferDone,
00123   .FillBufferDone  = NULL
00124 };
00125 
00126 OMX_CALLBACKTYPE volumecallbacks = {
00127   .EventHandler    = volumeEventHandler,
00128   .EmptyBufferDone = volumeEmptyBufferDone,
00129   .FillBufferDone  = volumeFillBufferDone
00130 };
00131 
00132 OMX_U32 out_width = 0, new_out_width = 0;  
00133 OMX_U32 out_height = 0, new_out_height = 0;
00134 
00135 appPrivateType* appPriv;
00136 
00137 char *input_file, *output_file_audio, *output_file_video;
00138 
00139 FILE *outfileAudio, *outfileVideo;
00140 
00141 int flagIsAudioOutputFileExpected;       /* to write the audio output to a file */
00142 int flagIsVideoOutputFileExpected;       /* to write the video output to a file */
00143 int flagDecodedOutputReceived;  
00144 int flagInputReceived;
00145 int flagIsDisplayRequested;     /* If Display is ON - volume and color components are chosen by default */
00146 int flagSetupTunnel;
00147 int flagAVsync;                 /* to select the AVsync option 1 = AV sync ON, clock component selected, 0 = no clock component selected*/
00148 
00149 static void setHeader(OMX_PTR header, OMX_U32 size) {
00150   OMX_VERSIONTYPE* ver = (OMX_VERSIONTYPE*)(header + sizeof(OMX_U32));
00151   *((OMX_U32*)header) = size;
00152 
00153   ver->s.nVersionMajor = VERSIONMAJOR;
00154   ver->s.nVersionMinor = VERSIONMINOR;
00155   ver->s.nRevision = VERSIONREVISION;
00156   ver->s.nStep = VERSIONSTEP;
00157 }
00158 
00162 int SetPortParametersAudio() {
00163   OMX_ERRORTYPE err = OMX_ErrorNone;
00164 
00165   // getting port parameters from parser3gp component //
00166   paramPortAudio.nPortIndex = AUDIO_PORT_INDEX; //audio port of the parser3gp
00167   setHeader(&paramPortAudio, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00168   err = OMX_GetParameter(appPriv->parser3gphandle, OMX_IndexParamPortDefinition, &paramPortAudio);
00169   if(err != OMX_ErrorNone) {
00170     DEBUG(DEB_LEV_ERR,"\n error in parser3gp port settings get\n");  
00171     exit(1);
00172   }
00173 
00174   // setting the port parameters of audio decoder
00175   // input port settings
00176   decparamPortAudio.nPortIndex = 0; /* input port of the audio decoder */
00177   setHeader(&decparamPortAudio, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00178   err = OMX_GetParameter(appPriv->audiodechandle, OMX_IndexParamPortDefinition, &decparamPortAudio);
00179   if(err != OMX_ErrorNone) {
00180     DEBUG(DEB_LEV_ERR,"\n error in audiodechandle settings get\n");  
00181     exit(1);
00182   }
00183 
00184   decparamPortAudio.format.audio.eEncoding=paramPortAudio.format.audio.eEncoding;
00185   err = OMX_SetParameter(appPriv->audiodechandle, OMX_IndexParamPortDefinition, &decparamPortAudio);
00186   if(err != OMX_ErrorNone) {
00187     DEBUG(DEB_LEV_ERR,"Error %08x setting audiodec input port param --- \n",err);
00188     exit(1);
00189   } 
00190 
00191   // output port settings
00192   decparamPortAudio.nPortIndex = 1;
00193   setHeader(&decparamPortAudio, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00194   err = OMX_GetParameter(appPriv->audiodechandle, OMX_IndexParamPortDefinition, &decparamPortAudio);
00195   if(err != OMX_ErrorNone) {
00196     DEBUG(DEB_LEV_ERR,"\n error in audiodechandle settings get\n");
00197     exit(1);
00198   }
00199 
00200   decparamPortAudio.format.audio.eEncoding=paramPortAudio.format.audio.eEncoding;
00201   err = OMX_SetParameter(appPriv->audiodechandle, OMX_IndexParamPortDefinition, &decparamPortAudio);
00202   if(err != OMX_ErrorNone) {
00203     DEBUG(DEB_LEV_ERR,"Error %08x setting audiodec output port param --- \n",err);
00204     exit(1);
00205   }
00206 
00207   return err;
00208 }
00209 
00213 int SetPortParametersVideo() {
00214   OMX_ERRORTYPE err = OMX_ErrorNone;
00215   OMX_PARAM_PORTDEFINITIONTYPE omx_colorconvPortDefinition;
00216 
00217   // getting port parameters from parser3gp component //
00218   paramPortVideo.nPortIndex = VIDEO_PORT_INDEX; //video port of the parser3gp
00219   setHeader(&paramPortVideo, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00220   err = OMX_GetParameter(appPriv->parser3gphandle, OMX_IndexParamPortDefinition, &paramPortVideo);
00221   if(err != OMX_ErrorNone) {
00222     DEBUG(DEB_LEV_ERR,"\n error in parser3gp port settings get\n");  
00223     exit(1);
00224   }
00225 
00226  // setting the port parameters of video decoder
00227  // input port settings
00228   decparamPortVideo.nPortIndex = 0; /* input port of the video decoder */
00229   setHeader(&decparamPortVideo, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00230   err = OMX_GetParameter(appPriv->videodechandle, OMX_IndexParamPortDefinition, &decparamPortVideo);
00231   if(err != OMX_ErrorNone) {
00232     DEBUG(DEB_LEV_ERR,"\n error in videodechandle settings get\n");  
00233     exit(1);
00234   }
00235 
00236   decparamPortVideo.format.video.eCompressionFormat=paramPortVideo.format.video.eCompressionFormat;
00237   decparamPortVideo.format.video.nFrameWidth=paramPortVideo.format.video.nFrameWidth;
00238   decparamPortVideo.format.video.nFrameHeight=paramPortVideo.format.video.nFrameHeight; 
00239   err = OMX_SetParameter(appPriv->videodechandle, OMX_IndexParamPortDefinition, &decparamPortVideo);
00240   if(err != OMX_ErrorNone) {
00241     DEBUG(DEB_LEV_ERR,"Error %08x setting videodec input port param --- \n",err);
00242     exit(1);
00243   } 
00244 
00245  // output port settings
00246   decparamPortVideo.nPortIndex = 1;
00247   setHeader(&decparamPortVideo, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00248   err = OMX_GetParameter(appPriv->videodechandle, OMX_IndexParamPortDefinition, &decparamPortVideo);
00249   if(err != OMX_ErrorNone) {
00250     DEBUG(DEB_LEV_ERR,"\n error in videodechandle settings get\n");
00251     exit(1);
00252   }
00253 
00254   decparamPortVideo.format.video.eCompressionFormat=paramPortVideo.format.video.eCompressionFormat;
00255   decparamPortVideo.format.video.nFrameWidth=paramPortVideo.format.video.nFrameWidth;
00256   decparamPortVideo.format.video.nFrameHeight=paramPortVideo.format.video.nFrameHeight; 
00257   err = OMX_SetParameter(appPriv->videodechandle, OMX_IndexParamPortDefinition, &decparamPortVideo);
00258   if(err != OMX_ErrorNone) {
00259     DEBUG(DEB_LEV_ERR,"Error %08x setting videodec output port param --- \n",err);
00260     exit(1);
00261   }
00262 
00263   new_out_width = paramPortVideo.format.video.nFrameWidth;  
00264   new_out_height = paramPortVideo.format.video.nFrameHeight; 
00265   DEBUG(DEB_LEV_SIMPLE_SEQ, "input picture width : %d height : %d \n", (int)new_out_width, (int)new_out_height);
00266 
00270   if(flagIsDisplayRequested == 1) {
00274     omx_colorconvPortDefinition.nPortIndex = 0;
00275     setHeader(&omx_colorconvPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00276     err = OMX_GetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00277     omx_colorconvPortDefinition.format.video.nFrameWidth = new_out_width;
00278     omx_colorconvPortDefinition.format.video.nFrameHeight = new_out_height;
00279     err = OMX_SetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00280     if(err!=OMX_ErrorNone) {
00281       DEBUG(DEB_LEV_ERR, "In %s Setting Input Port Definition Error=%x\n",__func__,err);
00282       return err;
00283     }
00287     omx_colorconvPortDefinition.nPortIndex = 1;
00288     err = OMX_GetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00289     omx_colorconvPortDefinition.format.video.nFrameWidth = new_out_width;
00290     omx_colorconvPortDefinition.format.video.nFrameHeight = new_out_height;
00291     err = OMX_SetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00292     if(err!=OMX_ErrorNone) {
00293       DEBUG(DEB_LEV_ERR, "In %s Setting Output Port Definition Error=%x\n",__func__,err);
00294       return err;
00295     }
00299     paramPortVideo.nPortIndex = 1;
00300     setHeader(&paramPortVideo, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00301     err = OMX_GetParameter(appPriv->videodechandle, OMX_IndexParamPortDefinition, &paramPortVideo);
00302     omx_colorconvPortDefinition.nPortIndex = 0;
00303     setHeader(&omx_colorconvPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00304     err = OMX_GetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00305     omx_colorconvPortDefinition.format.video.eColorFormat = paramPortVideo.format.video.eColorFormat;  
00306     err = OMX_SetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00307     if(err==OMX_ErrorBadParameter) {
00308       DEBUG(DEB_LEV_ERR,"\n bad parameter of input color format - exiting\n");
00309       exit(1);
00310     }
00312     omx_colorconvPortDefinition.nPortIndex = 1;
00313     err = OMX_GetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00314     omx_colorconvPortDefinition.format.video.eColorFormat = COLOR_CONV_OUT_RGB_FORMAT;
00315     err = OMX_SetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00316     if(err==OMX_ErrorBadParameter) {
00317       DEBUG(DEB_LEV_ERR,"\n bad parameter of output color format setting- exiting\n");
00318       exit(1);
00319     }
00323     omx_colorconvPortDefinition.nPortIndex = 1; //color converter output port index
00324     err = OMX_GetParameter(appPriv->colorconv_handle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00325     omx_colorconvPortDefinition.nPortIndex = 0; //sink input port index
00326     err = OMX_SetParameter(appPriv->videosinkhandle, OMX_IndexParamPortDefinition, &omx_colorconvPortDefinition);
00327     if(err != OMX_ErrorNone) {
00328       DEBUG(DEB_LEV_ERR,"\n error in setting the inputport param of the sink component- exiting\n");
00329       exit(1);
00330     }
00331   }
00332   return err;
00333 }
00334 
00335 void display_help() {
00336   printf("\n");
00337   printf("Usage: omxparsertest -vo outfileVideo.yuv -ao outfileAudio.pcm  [-t]  [-h] [-d] [-c] input_filename\n");
00338   printf("\n");
00339   printf("       -ao outfileAudio.pcm \n"); 
00340   printf("       -vo outfileVideo.yuv \n"); 
00341   printf("                   If this option is specified, the output is written to user specified outfiles\n");
00342   printf("                   N.B : This option is not needed if you use the sink component\n");
00343   printf("\n");
00344   printf("       -h: Displays this help\n");
00345   printf("\n");
00346   printf("       -c: clock component selected AVsync ON\n");
00347   printf("\n");
00348   printf("       -d: Uses the video and alsa sink component to display the video and play the audio output \n");
00349   printf("       input_filename is the user specified input file name\n");
00350   printf("\n");
00351   printf("       -t: Tunneling option - if this option is selected then by default the color converter, \n");
00352   printf("           video sink, volume control and alsa sink components are selected even if these options \n");
00353   printf("           are not specified - the components are tunneled between themselves\n");
00354   printf("\n");
00355   exit(1);
00356 } 
00357 
00358 OMX_ERRORTYPE test_OMX_ComponentNameEnum() {
00359   char * name;
00360   int index;
00361 
00362   OMX_ERRORTYPE err = OMX_ErrorNone;
00363 
00364   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00365   name = malloc(OMX_MAX_STRINGNAME_SIZE);
00366   index = 0;
00367   while(1) {
00368     err = OMX_ComponentNameEnum (name, OMX_MAX_STRINGNAME_SIZE, index);
00369     if ((name != NULL) && (err == OMX_ErrorNone)) {
00370       DEBUG(DEFAULT_MESSAGES, "component %i is %s\n",index, name);
00371     } else break;
00372     if (err != OMX_ErrorNone) break;
00373       index++;
00374   }
00375   free(name);
00376   name = NULL;
00377   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00378   return err;
00379 }
00380 
00381 OMX_ERRORTYPE test_OMX_RoleEnum(OMX_STRING component_name) {
00382   OMX_U32 no_of_roles;
00383   OMX_U8 **string_of_roles;
00384   OMX_ERRORTYPE err = OMX_ErrorNone;
00385   int index;
00386 
00387   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00388   DEBUG(DEB_LEV_SIMPLE_SEQ, "Getting roles of %s. Passing Null first...\n", component_name);
00389   err = OMX_GetRolesOfComponent(component_name, &no_of_roles, NULL);
00390   if (err != OMX_ErrorNone) {
00391     DEBUG(DEB_LEV_ERR, "Not able to retrieve the number of roles of the given component\n");
00392     DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00393     return err;
00394   }
00395   DEBUG(DEFAULT_MESSAGES, "The number of roles for the component %s is: %i\n", component_name, (int)no_of_roles);
00396 
00397   if(no_of_roles == 0) {
00398     DEBUG(DEB_LEV_ERR, "The Number or roles is 0.\nThe component selected is not correct for the purpose of this test.\nExiting...\n");    
00399     err = OMX_ErrorInvalidComponentName;
00400   }  else {
00401     string_of_roles = (OMX_U8**)malloc(no_of_roles * sizeof(OMX_STRING));
00402     for (index = 0; index<no_of_roles; index++) {
00403       *(string_of_roles + index) = (OMX_U8 *)malloc(no_of_roles*OMX_MAX_STRINGNAME_SIZE);
00404     }
00405     DEBUG(DEB_LEV_SIMPLE_SEQ, "...then buffers\n");
00406 
00407     err = OMX_GetRolesOfComponent(component_name, &no_of_roles, string_of_roles);
00408     if (err != OMX_ErrorNone) {
00409       DEBUG(DEB_LEV_ERR, "Not able to retrieve the roles of the given component\n");
00410     } else if(string_of_roles != NULL) {
00411       for (index = 0; index < no_of_roles; index++) {
00412         DEBUG(DEFAULT_MESSAGES, "The role %i for the component:  %s \n", (index + 1), *(string_of_roles+index));
00413       }
00414     } else {
00415       DEBUG(DEB_LEV_ERR, "role string is NULL!!! Exiting...\n");
00416       err = OMX_ErrorInvalidComponentName;
00417     }
00418     for (index = 0; index<no_of_roles; index++) {
00419       free(*(string_of_roles + index));
00420     }
00421     free(string_of_roles);
00422   }
00423   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00424   return err;
00425 }
00426 
00427 OMX_ERRORTYPE test_OMX_ComponentEnumByRole(OMX_STRING role_name) {
00428   OMX_U32 no_of_comp_per_role;
00429   OMX_U8 **string_of_comp_per_role;
00430   OMX_ERRORTYPE err;
00431   int index;
00432 
00433   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00434   
00435   DEBUG(DEFAULT_MESSAGES, "Getting number of components per role for %s\n", role_name);
00436 
00437   err = OMX_GetComponentsOfRole(role_name, &no_of_comp_per_role, NULL);
00438   if (err != OMX_ErrorNone) {
00439     DEBUG(DEB_LEV_ERR, "Not able to retrieve the number of components of a given role\n");
00440     DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00441     return err;
00442   }
00443   DEBUG(DEFAULT_MESSAGES, "Number of components per role for %s is %i\n", role_name, (int)no_of_comp_per_role);
00444 
00445   string_of_comp_per_role = (OMX_U8**)malloc(no_of_comp_per_role * sizeof(OMX_STRING));
00446   for (index = 0; index<no_of_comp_per_role; index++) {
00447     string_of_comp_per_role[index] = malloc(OMX_MAX_STRINGNAME_SIZE);
00448   }
00449 
00450   err = OMX_GetComponentsOfRole(role_name, &no_of_comp_per_role, string_of_comp_per_role);
00451   if (err != OMX_ErrorNone) {
00452     DEBUG(DEB_LEV_ERR, "Not able to retrieve the components of a given role\n");
00453     DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00454     for (index = 0; index<no_of_comp_per_role; index++) {
00455       if(string_of_comp_per_role[index]) {
00456         free(string_of_comp_per_role[index]);
00457         string_of_comp_per_role[index] = NULL;
00458       }
00459     }
00460 
00461     if(string_of_comp_per_role)  {
00462       free(string_of_comp_per_role);
00463       string_of_comp_per_role = NULL;
00464     }
00465     return err;
00466   }
00467 
00468   DEBUG(DEFAULT_MESSAGES, " The components are:\n");
00469   for (index = 0; index < no_of_comp_per_role; index++) {
00470     DEBUG(DEFAULT_MESSAGES, "%s\n", string_of_comp_per_role[index]);
00471   }
00472   for (index = 0; index<no_of_comp_per_role; index++) {
00473     if(string_of_comp_per_role[index]) {
00474       free(string_of_comp_per_role[index]);
00475       string_of_comp_per_role[index] = NULL;
00476     }
00477   }
00478 
00479   if(string_of_comp_per_role)  {
00480     free(string_of_comp_per_role);
00481     string_of_comp_per_role = NULL;
00482   }
00483   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result OMX_ErrorNone\n",__func__);
00484   return OMX_ErrorNone;
00485 }
00486 
00487 OMX_ERRORTYPE test_OpenClose(OMX_STRING component_name) {
00488   OMX_ERRORTYPE err = OMX_ErrorNone;
00489 
00490   DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00491   if(strcmp(component_name, AUDIO_COMPONENT_NAME_BASE) == 0){
00492      err = OMX_GetHandle(&appPriv->audiodechandle, component_name, NULL, &audiodeccallbacks);
00493      if(err != OMX_ErrorNone) {
00494        DEBUG(DEB_LEV_ERR, "No component found\n");
00495      } else {
00496        err = OMX_FreeHandle(appPriv->audiodechandle);
00497        if(err != OMX_ErrorNone) {
00498          DEBUG(DEB_LEV_ERR, "In %s err %08x in Free Handle\n",__func__,err);
00499        }
00500      }
00501    } else if(strcmp(component_name, VIDEO_COMPONENT_NAME_BASE) == 0){
00502      err = OMX_GetHandle(&appPriv->videodechandle, component_name, NULL , &videodeccallbacks);
00503      if(err != OMX_ErrorNone) {
00504        DEBUG(DEB_LEV_ERR, "No component found\n");
00505      } else {
00506        err = OMX_FreeHandle(appPriv->videodechandle);
00507        if(err != OMX_ErrorNone) {
00508          DEBUG(DEB_LEV_ERR, "In %s err %08x in Free Handle\n",__func__,err);
00509        }
00510      }
00511    }
00512 
00513    DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00514   return err;
00515 }
00516 
00517 int main(int argc, char** argv) {
00518   int argn_dec;
00519   char *temp                          = NULL;
00520   int gain                            = -1;
00521   OMX_ERRORTYPE                       err;
00522   OMX_INDEXTYPE                       eIndexParamFilename;
00523   OMX_PARAM_COMPONENTROLETYPE         sComponentRole; 
00524   OMX_AUDIO_CONFIG_VOLUMETYPE         sVolume;
00525   OMX_TIME_CONFIG_CLOCKSTATETYPE      sClockState;
00526   OMX_TIME_CONFIG_SCALETYPE           sConfigScale;
00527   OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE  sRefClock;
00528   char keyin;
00529   OMX_S32  newscale=0;
00530 
00531 
00532   if(argc < 2){
00533     display_help();
00534   } else {
00535     flagIsVideoOutputFileExpected = 0;
00536     flagIsAudioOutputFileExpected = 0;
00537     flagDecodedOutputReceived = 0;
00538     flagInputReceived = 0;
00539     flagSetupTunnel = 0;
00540     flagIsDisplayRequested = 0;
00541     flagAVsync             =0;
00542 
00543     argn_dec = 1;
00544     while (argn_dec < argc) {
00545       if (*(argv[argn_dec]) == '-') {
00546         if (flagIsVideoOutputFileExpected || flagIsAudioOutputFileExpected) {
00547           display_help();
00548         }
00549         switch (*(argv[argn_dec] + 1)) {
00550         case 'h' :
00551           display_help();
00552           break;
00553         case 't' :
00554           flagSetupTunnel = 1;
00555           flagIsDisplayRequested = 1;
00556           break;
00557         case 'd':
00558           flagIsDisplayRequested = 1;
00559           break;
00560         case 'c':
00561           flagAVsync = 1;
00562           break;
00563         case 'a' :
00564           if(*(argv[argn_dec] + 2)=='o'){
00565             flagIsAudioOutputFileExpected = 1;
00566           }
00567           break;
00568         case 'v' :
00569           if(*(argv[argn_dec] + 2)=='o'){
00570             flagIsVideoOutputFileExpected = 1;
00571           }
00572           break;
00573         default:
00574           display_help();
00575         }
00576       } else {
00577         if (flagIsVideoOutputFileExpected) {
00578           if(strstr(argv[argn_dec], ".yuv") != NULL) {
00579             output_file_video = malloc(strlen(argv[argn_dec]) * sizeof(char) + 1);
00580             strcpy(output_file_video,argv[argn_dec]);
00581           }    
00582           flagIsVideoOutputFileExpected = 0;
00583           flagDecodedOutputReceived = 1; 
00584         } else if (flagIsAudioOutputFileExpected){
00585           if (strstr(argv[argn_dec], ".pcm") != NULL) {
00586             output_file_audio = malloc(strlen(argv[argn_dec]) * sizeof(char) + 1);
00587             strcpy(output_file_audio,argv[argn_dec]);
00588           }
00589           flagIsAudioOutputFileExpected = 0;
00590           flagDecodedOutputReceived = 1; 
00591         } else {
00592           input_file = malloc(strlen(argv[argn_dec]) * sizeof(char) + 1);
00593           strcpy(input_file,argv[argn_dec]);
00594           flagInputReceived = 1;
00595         }
00596       }
00597       argn_dec++;
00598     }
00599 
00601     if ((!flagInputReceived) || ((strstr(input_file, ".3gp") == NULL))) {
00602       DEBUG(DEB_LEV_ERR, "\n you must specify appropriate input file of .3gp format\n");
00603       display_help();
00604     }
00605 
00607     //case 1 - user did not specify output file names
00608     if(flagIsAudioOutputFileExpected || flagIsVideoOutputFileExpected) {
00609        DEBUG(DEB_LEV_ERR, "\n you must specify appropriate output audio and video file names \n");
00610        display_help();
00611     }
00612 
00613     if(flagDecodedOutputReceived) {
00614       if(flagIsDisplayRequested || flagSetupTunnel) {
00615         flagDecodedOutputReceived = 0; 
00616         DEBUG(DEB_LEV_ERR, "Display Requested or Components are tunneled. No FILE Output will be produced\n");
00617       }
00618     }
00619    
00620     DEBUG(DEFAULT_MESSAGES, "Options selected:\n");
00621     if(flagDecodedOutputReceived) {
00622       DEBUG(DEFAULT_MESSAGES, "Decode file %s to produce audio file %s and video file %s\n", input_file, output_file_audio, output_file_video);
00623     } else {
00624       DEBUG(DEFAULT_MESSAGES, "As audio and video sink components are chosen, no output file is generated even if specified\n");
00625     }
00626     if(flagIsDisplayRequested) {
00627       DEBUG(DEFAULT_MESSAGES, "See the movie being played....\n");
00628     }
00629     if(flagSetupTunnel) {
00630       DEBUG(DEFAULT_MESSAGES,"The components are tunneled between themselves\n");
00631     }
00632   }
00633 
00634   if(!flagIsDisplayRequested) {
00635     if(output_file_audio==NULL || output_file_video==NULL) {
00636       DEBUG(DEB_LEV_ERR, "\n Error in specifying audio/video output filename ....,\n");
00637       if(output_file_audio==NULL) DEBUG(DEB_LEV_ERR, "  For audio output specify a filename with .pcm extension\n");
00638       if(output_file_video==NULL) DEBUG(DEB_LEV_ERR, "  For video output specify a filename with .yuv extension\n");
00639       display_help();
00640       exit(1);
00641     }
00642     outfileAudio = fopen(output_file_audio, "wb");
00643     if(outfileAudio == NULL) {
00644       DEBUG(DEB_LEV_ERR, "Error in opening output file %s\n", output_file_audio);
00645       exit(1);
00646     }
00647     outfileVideo = fopen(output_file_video, "wb");
00648     if(outfileVideo == NULL) {
00649       DEBUG(DEB_LEV_ERR, "Error in opening output file %s\n", output_file_video);
00650       exit(1);
00651     }
00652   }
00653 
00655   out_width = 640;
00656   out_height = 480;
00657 
00659   appPriv = malloc(sizeof(appPrivateType));
00660   appPriv->parser3gpEventSem = malloc(sizeof(tsem_t));
00661   appPriv->videoDecoderEventSem = malloc(sizeof(tsem_t));
00662   appPriv->audioDecoderEventSem = malloc(sizeof(tsem_t));
00663   if(flagIsDisplayRequested == 1) {
00664     appPriv->fbdevSinkEventSem = malloc(sizeof(tsem_t));
00665     appPriv->colorconvEventSem = malloc(sizeof(tsem_t));
00666     appPriv->audioSinkEventSem = malloc(sizeof(tsem_t));
00667     appPriv->volumeEventSem = malloc(sizeof(tsem_t));
00668   }
00669   appPriv->eofSem = malloc(sizeof(tsem_t));
00670   if(flagAVsync) {
00671     appPriv->clockEventSem = malloc(sizeof(tsem_t));
00672   } 
00673 
00674   tsem_init(appPriv->parser3gpEventSem, 0);
00675   tsem_init(appPriv->videoDecoderEventSem, 0);
00676   tsem_init(appPriv->audioDecoderEventSem, 0);
00677   if(flagIsDisplayRequested == 1) {
00678     tsem_init(appPriv->fbdevSinkEventSem, 0);
00679     tsem_init(appPriv->colorconvEventSem, 0);
00680     tsem_init(appPriv->audioSinkEventSem, 0);
00681     tsem_init(appPriv->volumeEventSem, 0);
00682   }
00683   tsem_init(appPriv->eofSem, 0); 
00684   if(flagAVsync) {
00685     tsem_init(appPriv->clockEventSem, 0); 
00686   }
00687 
00689   err = OMX_Init();
00690   if (err != OMX_ErrorNone) {
00691     DEBUG(DEB_LEV_ERR, "The OpenMAX core can not be initialized. Exiting...\n");
00692     exit(1);
00693   }else {
00694     DEBUG(DEB_LEV_SIMPLE_SEQ, "Omx core is initialized \n");
00695   }
00696 
00697   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00698   test_OMX_ComponentNameEnum();
00699   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00700   test_OMX_RoleEnum(VIDEO_COMPONENT_NAME_BASE);
00701   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00702   test_OMX_ComponentEnumByRole(VIDEO_BASE_ROLE);
00703   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00704   test_OMX_RoleEnum(AUDIO_COMPONENT_NAME_BASE);
00705   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00706   test_OMX_ComponentEnumByRole(AUDIO_BASE_ROLE);
00707   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00708   test_OpenClose(VIDEO_COMPONENT_NAME_BASE);
00709   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00710   test_OpenClose(AUDIO_COMPONENT_NAME_BASE);
00711   DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00712 
00713   DEBUG(DEFAULT_MESSAGES, "The component selected for video decoding is %s\n Role is decided by the decoder\n", VIDEO_COMPONENT_NAME_BASE);
00714   DEBUG(DEFAULT_MESSAGES, "The component selected for audio decoding is %s\n Role is decided by the decoder\n", AUDIO_COMPONENT_NAME_BASE);
00715 
00716   DEBUG(DEB_LEV_SIMPLE_SEQ, "Using Parser3gp \n");
00718   err = OMX_GetHandle(&appPriv->parser3gphandle, PARSER_3GP, NULL /*appPriv */, &parser3gpcallbacks);
00719   if(err != OMX_ErrorNone) {
00720     DEBUG(DEB_LEV_ERR, "Parser3gp Component Not Found\n");
00721     exit(1);
00722   } else {
00723     DEBUG(DEFAULT_MESSAGES, "Parser3gp Component Found\n");
00724   } 
00725 
00726  /* getting the handle to the clock src component */
00727  if(flagAVsync){
00728    err = OMX_GetHandle(&appPriv->clocksrchandle, CLOCK_SRC, NULL, &clocksrccallbacks);
00729    if(err != OMX_ErrorNone) {
00730         DEBUG(DEB_LEV_ERR, "Clocksrc Component Not Found\n");
00731          exit(1);
00732    } else {
00733         DEBUG(DEFAULT_MESSAGES, "Clocksrc Component Found\n");
00734    }
00735  }
00736 
00737  /* getting the handles for the components in video  and audio piepline*/
00739   err = OMX_GetHandle(&appPriv->videodechandle, VIDEO_COMPONENT_NAME_BASE, NULL, &videodeccallbacks);
00740   if(err != OMX_ErrorNone){
00741     DEBUG(DEB_LEV_ERR, "No video decoder component found. Exiting...\n");
00742     exit(1);
00743   } else {
00744     DEBUG(DEFAULT_MESSAGES, "The component for video decoding is %s\n", VIDEO_COMPONENT_NAME_BASE);
00745   }
00746 
00748   DEBUG(DEB_LEV_SIMPLE_SEQ, "Getting Audio %s Decoder Handle\n",AUDIO_COMPONENT_NAME_BASE);
00749   err = OMX_GetHandle(&appPriv->audiodechandle, AUDIO_COMPONENT_NAME_BASE, NULL, &audiodeccallbacks);
00750   if(err != OMX_ErrorNone) {
00751     DEBUG(DEB_LEV_ERR, "Audio Decoder Component Not Found\n");
00752     exit(1);
00753   }
00754   DEBUG(DEFAULT_MESSAGES, "The Component for audio deoding is %s \n", AUDIO_COMPONENT_NAME_BASE);
00755 
00757   if(flagIsDisplayRequested) {
00759     err = OMX_GetHandle(&appPriv->colorconv_handle, COLOR_CONV, NULL, &colorconv_callbacks);
00760     if(err != OMX_ErrorNone){
00761       DEBUG(DEB_LEV_ERR, "No color converter component found. Exiting...\n");
00762       exit(1);
00763     } else {
00764       DEBUG(DEFAULT_MESSAGES, "Found The component for color converter \n");
00765     }
00766 
00768     err = OMX_GetHandle(&appPriv->videosinkhandle, VIDEO_SINK, NULL, &fbdev_sink_callbacks);
00769     if(err != OMX_ErrorNone){
00770       DEBUG(DEB_LEV_ERR, "No video sink component component found. Exiting...\n");
00771        exit(1);
00772     } else {
00773        DEBUG(DEFAULT_MESSAGES, "Found The video sink component for color converter \n");
00774     }
00775   
00777     err = OMX_GetHandle(&appPriv->audiosinkhandle, AUDIO_SINK, NULL , &audiosinkcallbacks);
00778     if(err != OMX_ErrorNone){
00779       DEBUG(DEB_LEV_ERR, "No audio sink found. Exiting...\n");
00780       exit(1);
00781     } else {
00782        DEBUG(DEFAULT_MESSAGES, "Found The alsa sink component for audio \n");
00783     }
00784 
00786     DEBUG(DEFAULT_MESSAGES, "Getting Handle for Component %s\n", AUDIO_EFFECT);
00787     err = OMX_GetHandle(&appPriv->volumehandle, AUDIO_EFFECT, NULL , &volumecallbacks);
00788     if(err != OMX_ErrorNone){
00789       DEBUG(DEB_LEV_ERR, "No volume component found. Exiting...\n");
00790       exit(1);
00791     } else {
00792       DEBUG(DEFAULT_MESSAGES, "Found The volume component for audio \n");
00793     }
00794 
00795     if((gain >= 0) && (gain <100)) {
00796       err = OMX_GetConfig(appPriv->volumehandle, OMX_IndexConfigAudioVolume, &sVolume);
00797       if(err!=OMX_ErrorNone) {
00798         DEBUG(DEB_LEV_ERR,"Error %08x In OMX_GetConfig 0 \n",err);
00799       }
00800       sVolume.sVolume.nValue = gain;
00801       DEBUG(DEFAULT_MESSAGES, "Setting Gain %d \n", gain);
00802       err = OMX_SetConfig(appPriv->volumehandle, OMX_IndexConfigAudioVolume, &sVolume);
00803       if(err!=OMX_ErrorNone) {
00804         DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig 0 \n",err);
00805       }
00806     }
00807   }
00808 
00809  /* disable the clock ports of the clients (audio, video and parser), if AVsync not enabled*/
00810  if(!flagAVsync) {
00811    err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortDisable, 1, NULL);
00812    if(err != OMX_ErrorNone) {
00813       DEBUG(DEB_LEV_ERR,"audiosink clock port disable failed\n");
00814       exit(1);
00815     }
00816     tsem_down(appPriv->audioSinkEventSem); /* audio sink clock port disabled */
00817     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Clock Port Disabled\n", __func__);
00818 
00819    err = OMX_SendCommand(appPriv->videosinkhandle, OMX_CommandPortDisable, 1, NULL);
00820    if(err != OMX_ErrorNone) {
00821       DEBUG(DEB_LEV_ERR,"videosink clock port disable failed\n");
00822       exit(1);
00823     }
00824     tsem_down(appPriv->fbdevSinkEventSem); /* video sink clock port disabled */
00825     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Video Sink Clock Port Disabled\n", __func__);
00826 
00827    err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandPortDisable, 2, NULL);
00828    if(err != OMX_ErrorNone) {
00829       DEBUG(DEB_LEV_ERR,"parser clock port disable failed\n");
00830       exit(1);
00831     }
00832     tsem_down(appPriv->parser3gpEventSem); /* parser clock port disabled */
00833     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s parser Clock Port Disabled\n", __func__);
00834 
00835  }
00836 
00838   err = OMX_GetExtensionIndex(appPriv->parser3gphandle,"OMX.ST.index.param.parser3gp.inputfilename",&eIndexParamFilename);
00839   if(err != OMX_ErrorNone) {
00840      DEBUG(DEB_LEV_ERR,"\n error in get extension index\n");
00841     exit(1);
00842   } else {
00843     DEBUG(DEB_LEV_SIMPLE_SEQ,"FileName Param index : %x \n",eIndexParamFilename);
00844     temp = (char *)malloc(25);
00845     OMX_GetParameter(appPriv->parser3gphandle,eIndexParamFilename,temp);
00846     err = OMX_SetParameter(appPriv->parser3gphandle,eIndexParamFilename,input_file);
00847     if(err != OMX_ErrorNone) {
00848       DEBUG(DEB_LEV_ERR,"\n error in input format - exiting\n");
00849       exit(1);
00850     }
00851   }
00852 
00853   /* Set up the tunnel between the clock component ports and the client clock ports and disable the rest of the ports */
00854   if(flagAVsync) {
00855     err = OMX_SetupTunnel(appPriv->clocksrchandle, AUDIO_PORT_INDEX, appPriv->audiosinkhandle, CLIENT_CLOCK_PORT_INDEX);
00856     if(err != OMX_ErrorNone) {
00857       DEBUG(DEB_LEV_ERR, "Set up Tunnel btwn clock and audio sink Failed Error=%x\n",err);
00858       exit(1);
00859     } else{
00860       DEBUG(DEB_LEV_ERR, "Setup Tunnel between clock and audio sink successful\n");
00861     }
00862 
00863     err = OMX_SetupTunnel(appPriv->clocksrchandle, VIDEO_PORT_INDEX, appPriv->videosinkhandle, CLIENT_CLOCK_PORT_INDEX);
00864     if(err != OMX_ErrorNone) {
00865       DEBUG(DEB_LEV_ERR, "Set up Tunnel btwn clock and video sink Failed\n");
00866       exit(1);
00867     } else{
00868       DEBUG(DEB_LEV_ERR, "Setup Tunnel between clock and video sink successful\n");
00869     }
00870 
00871     err = OMX_SetupTunnel(appPriv->clocksrchandle, PARSER_PORT_INDEX, appPriv->parser3gphandle, PARSER_CLOCK_PORT_INDEX);
00872     if(err != OMX_ErrorNone) {
00873       DEBUG(DEB_LEV_ERR, "Set up Tunnel btwn clock and parser3gp Failed\n");
00874       exit(1);
00875     } else{
00876       DEBUG(DEB_LEV_ERR, "Setup Tunnel between clock and parser3gp successful\n");
00877     }
00878 
00879    if(!flagSetupTunnel){
00880    /* disable the clock port on parser and the clock port on the clock component tunneled to the parser, till clock is put in Idle state*/
00881    err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandPortDisable, 2, NULL);
00882    if(err != OMX_ErrorNone) {
00883       DEBUG(DEB_LEV_ERR,"parser clock port disable failed\n");
00884       exit(1);
00885     }
00886     tsem_down(appPriv->parser3gpEventSem); /* parser clock port disabled */
00887     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s parser Clock Port Disabled\n", __func__);
00888 
00889    err = OMX_SendCommand(appPriv->clocksrchandle, OMX_CommandPortDisable, 2, NULL);
00890    if(err != OMX_ErrorNone) {
00891       DEBUG(DEB_LEV_ERR,"clocksrc component's clock  port (tunneled to parser's clock port) disable failed\n");
00892       exit(1);
00893     }
00894     tsem_down(appPriv->clockEventSem); /* clocksrc clock port disabled */
00895     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s clocksrc  Clock Port (connected to parser) Disabled\n", __func__);
00896    }
00897   }
00898 
00899   if (flagSetupTunnel) {
00900     DEBUG(DEB_LEV_SIMPLE_SEQ, "Setting up Tunnel\n");
00901     err = OMX_SetupTunnel(appPriv->parser3gphandle, VIDEO_PORT_INDEX, appPriv->videodechandle, 0);
00902     if(err != OMX_ErrorNone) {
00903       DEBUG(DEB_LEV_ERR, "Set up Tunnel parser3gp to video decoder Failed\n");
00904       exit(1);
00905     }
00906     err = OMX_SetupTunnel(appPriv->parser3gphandle, AUDIO_PORT_INDEX, appPriv->audiodechandle, 0);
00907     if(err != OMX_ErrorNone) {
00908       DEBUG(DEB_LEV_ERR, "Set up Tunnel parser3gp to audio decoder Failed\n");
00909       exit(1);
00910     }
00911     err = OMX_SetupTunnel(appPriv->videodechandle, 1, appPriv->colorconv_handle, 0);
00912     if(err != OMX_ErrorNone) {
00913       DEBUG(DEB_LEV_ERR, "Set up Tunnel video decoder to color converter Failed\n");
00914       exit(1);
00915     }
00916     err = OMX_SetupTunnel(appPriv->colorconv_handle, 1, appPriv->videosinkhandle, 0);
00917     if(err != OMX_ErrorNone) {
00918       DEBUG(DEB_LEV_ERR, "Set up Tunnel color converter to video sink Failed\n");
00919       exit(1);
00920     }
00921     err = OMX_SetupTunnel(appPriv->audiodechandle, 1, appPriv->volumehandle, 0);
00922     if(err != OMX_ErrorNone) {
00923       DEBUG(DEB_LEV_ERR, "Set up Tunnel audiodecoder to volume Failed\n");
00924       exit(1);
00925     }
00926     err = OMX_SetupTunnel(appPriv->volumehandle, 1, appPriv->audiosinkhandle, 0);
00927     if(err != OMX_ErrorNone) {
00928       DEBUG(DEB_LEV_ERR, "Set up Tunnel volume to audio sink Failed\n");
00929       exit(1);
00930     }
00931 
00932     DEBUG(DEB_LEV_SIMPLE_SEQ, "Set up Tunnel Completed\n");
00933 
00934     /* The decoder is the buffer supplier and parser is the consumer,
00935      not the other way round. This ensures that the first buffer is available when the decoder is in idle state. 
00936      This prevents the loss of the first frame buffer */
00937     OMX_PARAM_BUFFERSUPPLIERTYPE sBufferSupplier;
00938     sBufferSupplier.nPortIndex = 0;
00939     sBufferSupplier.eBufferSupplier = OMX_BufferSupplyInput;
00940     setHeader(&sBufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
00941 
00942     err = OMX_SetParameter(appPriv->videodechandle, OMX_IndexParamCompBufferSupplier, &sBufferSupplier);
00943     if(err!=OMX_ErrorNone) {
00944       DEBUG(DEB_LEV_ERR, "In %s Setting Video Decoder Input Port Buffer Supplier Error=%x\n",__func__,err);
00945       return err;
00946     }
00947     err = OMX_SetParameter(appPriv->audiodechandle, OMX_IndexParamCompBufferSupplier, &sBufferSupplier);
00948     if(err!=OMX_ErrorNone) {
00949       DEBUG(DEB_LEV_ERR, "In %s Setting Audio Decoder Input Port Buffer Supplier Error=%x\n",__func__,err);
00950       return err;
00951     }
00952   }
00953   
00954 
00956   OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00957 
00958   if (flagSetupTunnel) {
00959     DEBUG(DEB_LEV_SIMPLE_SEQ, "Send Command Idle to Video Dec\n");
00960     /*Send State Change Idle command to Video and Audio Decoder*/
00961     err = OMX_SendCommand(appPriv->videodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00962     err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00963     if(flagAVsync){
00964       err = OMX_SendCommand(appPriv->clocksrchandle,  OMX_CommandStateSet, OMX_StateIdle, NULL);
00965     }
00966     if (flagIsDisplayRequested) {
00967       DEBUG(DEB_LEV_SIMPLE_SEQ, "Send Command Idle to Audio and Video Sink\n");
00968       err = OMX_SendCommand(appPriv->colorconv_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00969       err = OMX_SendCommand(appPriv->videosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);  /* put in the idle state after the clock is put in idle state */
00970       err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00971       err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00972     }
00973   }
00974 
00975   /* In case tunnel is not set up then allocate the output buffers of the parser  
00976      two buffers for video port and two buffers for audio port */
00977   if (!flagSetupTunnel) {
00978     outBufferParseVideo[0] = outBufferParseVideo[1] = NULL;
00979     outBufferParseAudio[0] = outBufferParseAudio[1] = NULL;
00981     err = OMX_AllocateBuffer(appPriv->parser3gphandle, &outBufferParseVideo[0], VIDEO_PORT_INDEX, NULL, buffer_out_size);
00982     if(err != OMX_ErrorNone) {
00983       DEBUG(DEB_LEV_ERR, "Unable to allocate Video buffer 1 in parser3gp \n");
00984       exit(1);
00985     }
00986     err = OMX_AllocateBuffer(appPriv->parser3gphandle, &outBufferParseVideo[1], VIDEO_PORT_INDEX, NULL, buffer_out_size);
00987     if(err != OMX_ErrorNone) {
00988       DEBUG(DEB_LEV_ERR, "Unable to allocate Video buffer 2 in parser3gp \n");
00989       exit(1);
00990     }
00991 
00993     err = OMX_AllocateBuffer(appPriv->parser3gphandle, &outBufferParseAudio[0], AUDIO_PORT_INDEX, NULL, buffer_out_size);
00994     if(err != OMX_ErrorNone) {
00995       DEBUG(DEB_LEV_ERR, "Unable to allocate Audio buffer 1 in parser3gp \n");
00996       exit(1);
00997     }
00998     err = OMX_AllocateBuffer(appPriv->parser3gphandle, &outBufferParseAudio[1], AUDIO_PORT_INDEX, NULL, buffer_out_size);
00999     if(err != OMX_ErrorNone) {
01000       DEBUG(DEB_LEV_ERR, "Unable to allocate Audio buffer 2 in parser3gp \n");
01001       exit(1);
01002     }
01003   }
01004 
01005   /*Wait for Parser3gp  and clocksrc state change to Idle*/
01006   tsem_down(appPriv->parser3gpEventSem);
01007   DEBUG(DEFAULT_MESSAGES,"Parser3gp in idle state \n");
01008 
01009   /* Wait for all components to change to idle state*/
01010   if (flagSetupTunnel) {
01011     tsem_down(appPriv->videoDecoderEventSem);
01012     tsem_down(appPriv->audioDecoderEventSem);
01013     if (flagIsDisplayRequested) {
01014       tsem_down(appPriv->colorconvEventSem);
01015       tsem_down(appPriv->fbdevSinkEventSem);
01016       tsem_down(appPriv->volumeEventSem);
01017       tsem_down(appPriv->audioSinkEventSem);
01018     }
01019     if(flagAVsync){
01020       tsem_down(appPriv->clockEventSem);
01021     }
01022     DEBUG(DEFAULT_MESSAGES,"All tunneled components in idle state \n");
01023   }
01024 
01025     err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
01026     if(err != OMX_ErrorNone) {
01027       DEBUG(DEB_LEV_ERR,"Parser 3gp state executing failed\n");
01028       exit(1);
01029     }
01030     /*Wait for Parser3gp state change to executing*/
01031     tsem_down(appPriv->parser3gpEventSem);
01032     DEBUG(DEFAULT_MESSAGES,"Parser3gp in executing state \n");
01033 
01034     /*Wait for Parser3gp Ports Setting Changed Event. Since Parser3gp Always detect the stream
01035     Always ports setting change event will be received*/
01036     tsem_down(appPriv->parser3gpEventSem);
01037     tsem_down(appPriv->parser3gpEventSem);
01038     DEBUG(DEFAULT_MESSAGES,"Parser3gp Port Settings Changed event \n");
01039 
01040 
01041   /* for the tunneled case wait for all ports to be disabled */
01042   if(flagSetupTunnel){
01043      tsem_down(appPriv->parser3gpEventSem);  /* parser3gp Video o/p port disabled */
01044      tsem_down(appPriv->parser3gpEventSem);  /* parser3gp Audio o/p port disabled */
01045      DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Parser 3gp Component Ports Disabled\n", __func__);
01046      tsem_down(appPriv->videoDecoderEventSem);  /* Video decoder i/p port disabled */
01047      tsem_down(appPriv->videoDecoderEventSem);  /* Video decoder o/p port disabled */
01048      DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Video decoder Component Port Disabled\n", __func__);
01049      tsem_down(appPriv->audioDecoderEventSem);  /* Audio decoder i/p port disabled */
01050      tsem_down(appPriv->audioDecoderEventSem);  /* Audio decoder o/p port disabled */
01051      DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio decoder Component Port Disabled\n", __func__);
01052      if(flagIsDisplayRequested){
01053         tsem_down(appPriv->colorconvEventSem); /* color conv  i/p port disabled */
01054         tsem_down(appPriv->colorconvEventSem); /* color conv  o/p port disabled */
01055         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Color Converter Component Port Disabled\n", __func__);
01056         tsem_down(appPriv->fbdevSinkEventSem); /* sink i/p port disabled */
01057         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Video Sink Port Disabled\n", __func__);
01058         tsem_down(appPriv->volumeEventSem); /* volume  i/p port disabled */
01059         tsem_down(appPriv->volumeEventSem); /* volume  o/p port disabled */
01060         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Volume Component Port Disabled\n", __func__);
01061         tsem_down(appPriv->audioSinkEventSem); /* sink i/p port disabled */
01062         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Port Disabled\n", __func__);
01063      }    
01064    }
01065 
01066   /*  setting the port parameters and component role */
01067     SetPortParametersVideo(); 
01068     setHeader(&sComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
01069     err = OMX_GetParameter(appPriv->videodechandle,OMX_IndexParamStandardComponentRole,&sComponentRole); 
01070     switch(paramPortVideo.format.video.eCompressionFormat){
01071     case OMX_VIDEO_CodingMPEG4:
01072       strcpy((char*)&sComponentRole.cRole[0], VIDEO_DEC_MPEG4_ROLE);  
01073       break;
01074     case OMX_VIDEO_CodingAVC:
01075       strcpy((char*)&sComponentRole.cRole[0], VIDEO_DEC_H264_ROLE);
01076       break;
01077     default :
01078       DEBUG(DEB_LEV_ERR,"Error only MPEG4 and AVC(h.264) are supported %08x\n",paramPortVideo.format.video.eCompressionFormat); 
01079     }
01080     err = OMX_SetParameter(appPriv->videodechandle,OMX_IndexParamStandardComponentRole,&sComponentRole);
01081     if(err != OMX_ErrorNone) {
01082       DEBUG(DEB_LEV_ERR,"\n error in input video format - exiting\n");
01083       exit(1);
01084     }
01085 
01086    /* setting the component role for the audio component */
01087     SetPortParametersAudio();
01088     setHeader(&sComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
01089     err = OMX_GetParameter(appPriv->audiodechandle, OMX_IndexParamStandardComponentRole,&sComponentRole); 
01090     switch(paramPortAudio.format.audio.eEncoding){
01091     case OMX_AUDIO_CodingMP3:
01092       strcpy((char*)&sComponentRole.cRole[0], AUDIO_DEC_MP3_ROLE);  
01093       break;
01094     case OMX_AUDIO_CodingAAC:
01095       strcpy((char*)&sComponentRole.cRole[0],  AUDIO_DEC_AAC_ROLE);
01096       break;
01097     default :
01098       DEBUG(DEB_LEV_ERR,"Error only MP3 and AAC role are supported %08x\n",paramPortAudio.format.audio.eEncoding); 
01099     }
01100     err = OMX_SetParameter(appPriv->audiodechandle,OMX_IndexParamStandardComponentRole,&sComponentRole);
01101     if(err != OMX_ErrorNone) {
01102       DEBUG(DEB_LEV_ERR,"\n error in input audio format - exiting\n");
01103       exit(1);
01104     }
01105 
01106   if (flagSetupTunnel) {
01107    /* Enabling the ports after having set the parameters */
01108     err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandPortEnable, 0, NULL);
01109     err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandPortEnable, 1, NULL);
01110     err = OMX_SendCommand(appPriv->videodechandle, OMX_CommandPortEnable, -1, NULL);
01111     err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandPortEnable, -1, NULL);
01112     err = OMX_SendCommand(appPriv->colorconv_handle, OMX_CommandPortEnable, 0, NULL);
01113     err = OMX_SendCommand(appPriv->colorconv_handle, OMX_CommandPortEnable, 1, NULL);
01114     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortEnable, 0, NULL);
01115     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortEnable, 1, NULL);
01116     err = OMX_SendCommand(appPriv->videosinkhandle, OMX_CommandPortEnable, 0, NULL);
01117     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortEnable, 0, NULL);
01118     if(err != OMX_ErrorNone) {
01119        DEBUG(DEB_LEV_ERR,"audio sink port enable failed\n");
01120            exit(1);
01121     }
01122     /*Wait for Ports Enable Events*/
01123     tsem_down(appPriv->parser3gpEventSem);
01124     tsem_down(appPriv->parser3gpEventSem);
01125     tsem_down(appPriv->videoDecoderEventSem);
01126     tsem_down(appPriv->videoDecoderEventSem);
01127     tsem_down(appPriv->audioDecoderEventSem);
01128     tsem_down(appPriv->audioDecoderEventSem);
01129     tsem_down(appPriv->colorconvEventSem);
01130     tsem_down(appPriv->colorconvEventSem);
01131     tsem_down(appPriv->volumeEventSem);
01132     tsem_down(appPriv->volumeEventSem);
01133     tsem_down(appPriv->fbdevSinkEventSem);
01134     tsem_down(appPriv->audioSinkEventSem);
01135     DEBUG(DEB_LEV_SIMPLE_SEQ,"All ports enabled\n");
01136   }
01137 
01138   /*Send State Change Idle command to Video  & Audio Decoder*/
01139   if (!flagSetupTunnel) {
01140     err = OMX_SendCommand(appPriv->videodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01141 
01145     err = OMX_UseBuffer(appPriv->videodechandle, &inBufferVideoDec[0], 0, NULL, buffer_out_size, outBufferParseVideo[0]->pBuffer);
01146     if(err != OMX_ErrorNone) {
01147       DEBUG(DEB_LEV_ERR, "Unable to use the parser3gp comp allocate buffer\n");
01148       exit(1);
01149     }
01150     err = OMX_UseBuffer(appPriv->videodechandle, &inBufferVideoDec[1], 0, NULL, buffer_out_size, outBufferParseVideo[1]->pBuffer);
01151     if(err != OMX_ErrorNone) {
01152       DEBUG(DEB_LEV_ERR, "Unable to use the parser3gp comp allocate buffer\n");
01153       exit(1);
01154     }
01155 
01156    /* Allocate the output buffers of the video decoder */
01157     err = OMX_AllocateBuffer(appPriv->videodechandle, &outBufferVideoDec[0], 1, NULL, buffer_out_size);
01158     if(err != OMX_ErrorNone) {
01159       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in video dec\n");
01160       exit(1);
01161     }
01162     err = OMX_AllocateBuffer(appPriv->videodechandle, &outBufferVideoDec[1], 1, NULL, buffer_out_size);
01163     if(err != OMX_ErrorNone) {
01164       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in video dec\n");
01165       exit(1);
01166     }
01167 
01168     err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01169 
01173     err = OMX_UseBuffer(appPriv->audiodechandle, &inBufferAudioDec[0], 0, NULL, buffer_out_size, outBufferParseAudio[0]->pBuffer);
01174     if(err != OMX_ErrorNone) {
01175      DEBUG(DEB_LEV_ERR, "Unable to use the parser3gp allocate buffer\n");
01176      exit(1);
01177     }    
01178     err = OMX_UseBuffer(appPriv->audiodechandle, &inBufferAudioDec[1], 0, NULL, buffer_out_size, outBufferParseAudio[1]->pBuffer);
01179     if(err != OMX_ErrorNone) {
01180       DEBUG(DEB_LEV_ERR, "Unable to use the parser3gp allocate buffer\n");
01181       exit(1);
01182     }    
01183 
01184     /* Allocate the output buffers of the audio decoder */
01185     err = OMX_AllocateBuffer(appPriv->audiodechandle, &outBufferAudioDec[0], 1, NULL, buffer_out_size);
01186     if(err != OMX_ErrorNone) {
01187      DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in audio dec\n");
01188      exit(1);
01189     }
01190     err = OMX_AllocateBuffer(appPriv->audiodechandle, &outBufferAudioDec[1], 1, NULL, buffer_out_size);
01191     if(err != OMX_ErrorNone) {
01192      DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in audio dec\n");
01193      exit(1);
01194     }
01195 
01196     /*Wait for audio and video decoder state change to idle*/
01197     tsem_down(appPriv->videoDecoderEventSem);
01198     tsem_down(appPriv->audioDecoderEventSem);
01199     DEBUG(DEFAULT_MESSAGES," audio and video decoder transitioned to  idle state \n");
01200   }
01201 
01202 /*  color conv and sink options */
01203   if (flagIsDisplayRequested && (!flagSetupTunnel)) {
01204     err = OMX_SendCommand(appPriv->colorconv_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01205 
01206     err = OMX_UseBuffer(appPriv->colorconv_handle, &inBufferColorconv[0], 0, NULL, buffer_out_size, outBufferVideoDec[0]->pBuffer);
01207     if(err != OMX_ErrorNone) {
01208       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01209       exit(1);
01210     }
01211     err = OMX_UseBuffer(appPriv->colorconv_handle, &inBufferColorconv[1], 0, NULL, buffer_out_size, outBufferVideoDec[1]->pBuffer);
01212     if(err != OMX_ErrorNone) {
01213       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01214       exit(1);
01215     }
01216 
01217     err = OMX_AllocateBuffer(appPriv->colorconv_handle, &outBufferColorconv[0], 1, NULL, buffer_out_size);
01218     if(err != OMX_ErrorNone) {
01219       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in Color Converter 1\n");
01220       exit(1);
01221     }
01222     err = OMX_AllocateBuffer(appPriv->colorconv_handle, &outBufferColorconv[1], 1, NULL, buffer_out_size);
01223     if(err != OMX_ErrorNone) {
01224       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in Color Converter 2\n");
01225       exit(1);
01226     }
01227     /* wait for color converter to be in Idle state */
01228     tsem_down(appPriv->colorconvEventSem);
01229     DEBUG(DEB_LEV_SIMPLE_SEQ,"color converter state idle\n");
01230 
01231     /* volume control options */
01232     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01233 
01234     err = OMX_UseBuffer(appPriv->volumehandle, &inBufferVolume[0], 0, NULL, buffer_out_size, outBufferAudioDec[0]->pBuffer);
01235     if(err != OMX_ErrorNone) {
01236      DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01237      exit(1);
01238     }
01239     err = OMX_UseBuffer(appPriv->volumehandle, &inBufferVolume[1], 0, NULL, buffer_out_size, outBufferAudioDec[1]->pBuffer);
01240     if(err != OMX_ErrorNone) {
01241      DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01242      exit(1);
01243     }
01244 
01245     err = OMX_AllocateBuffer(appPriv->volumehandle, &outBufferVolume[0], 1, NULL, buffer_out_size);
01246     if(err != OMX_ErrorNone) {
01247      DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in volume 1\n");
01248      exit(1);
01249     }
01250     err = OMX_AllocateBuffer(appPriv->volumehandle, &outBufferVolume[1], 1, NULL, buffer_out_size);
01251     if(err != OMX_ErrorNone) {
01252       DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in volume 2\n");
01253       exit(1);
01254     }
01255 
01256     tsem_down(appPriv->volumeEventSem);
01257     DEBUG(DEB_LEV_SIMPLE_SEQ,"volume state idle\n");
01258 
01259 
01260    /* audio video sink and clock options */
01261     if(flagAVsync){
01262       err = OMX_SendCommand(appPriv->clocksrchandle,  OMX_CommandStateSet, OMX_StateIdle, NULL);
01263     }
01264     err = OMX_SendCommand(appPriv->videosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01265     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01266 
01267     err = OMX_UseBuffer(appPriv->videosinkhandle, &inBufferSinkVideo[0], 0, NULL, buffer_out_size, outBufferColorconv[0]->pBuffer);
01268     if(err != OMX_ErrorNone) {
01269       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01270       exit(1);
01271     }
01272     err = OMX_UseBuffer(appPriv->videosinkhandle, &inBufferSinkVideo[1], 0, NULL, buffer_out_size, outBufferColorconv[1]->pBuffer);
01273     if(err != OMX_ErrorNone) {
01274       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01275       exit(1);
01276     }
01277 
01278 
01279     err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSinkAudio[0], 0, NULL, buffer_out_size, outBufferVolume[0]->pBuffer);
01280     if(err != OMX_ErrorNone) {
01281       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01282       exit(1);
01283     }
01284     err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSinkAudio[1], 0, NULL, buffer_out_size, outBufferVolume[1]->pBuffer);
01285     if(err != OMX_ErrorNone) {
01286       DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01287       exit(1);
01288     }
01289 
01290     if(flagAVsync){
01291       tsem_down(appPriv->clockEventSem);
01292       DEBUG(DEFAULT_MESSAGES,"clock src  state idle\n");
01293     }
01294     tsem_down(appPriv->fbdevSinkEventSem);
01295     DEBUG(DEFAULT_MESSAGES,"video sink state idle\n");
01296     tsem_down(appPriv->audioSinkEventSem);
01297     DEBUG(DEFAULT_MESSAGES,"audio sink state idle\n");
01298   }
01299 
01300   if(flagAVsync && !flagSetupTunnel){
01301     /* enabling the clock port of the clocksrc connected to the parser and parser's clock port */
01302     err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandPortEnable, 2, NULL);
01303     err = OMX_SendCommand(appPriv->clocksrchandle,  OMX_CommandPortEnable, 2, NULL);
01304     /*Wait for Ports Enable Events*/
01305     tsem_down(appPriv->parser3gpEventSem);
01306     tsem_down(appPriv->clockEventSem);
01307   }
01308 
01309  /* putting the clock src in Executing state */
01310   if(flagAVsync){
01311     err = OMX_SendCommand(appPriv->clocksrchandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
01312     if(err != OMX_ErrorNone) {
01313       DEBUG(DEB_LEV_ERR,"clock src state executing failed\n");
01314       exit(1);
01315     }
01316 
01317     DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for  clock src state executing\n");
01318     tsem_down(appPriv->clockEventSem);
01319     DEBUG(DEFAULT_MESSAGES, "CLOCK SRC in EXECUTING state\n");
01320 
01321     /* set the audio as the master */ 
01322     setHeader(&sRefClock, sizeof(OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE));
01323     sRefClock.eClock = OMX_TIME_RefClockAudio;
01324     OMX_SetConfig(appPriv->clocksrchandle, OMX_IndexConfigTimeActiveRefClock,&sRefClock);
01325 
01326    /* set the clock state to OMX_TIME_ClockStateWaitingForStartTime */
01327     setHeader(&sClockState, sizeof(OMX_TIME_CONFIG_CLOCKSTATETYPE));
01328     err = OMX_GetConfig(appPriv->clocksrchandle, OMX_IndexConfigTimeClockState, &sClockState);
01329     sClockState.nWaitMask = OMX_CLOCKPORT1 || OMX_CLOCKPORT0;  /* wait for audio and video start time */
01330     sClockState.eState = OMX_TIME_ClockStateWaitingForStartTime;
01331     err = OMX_SetConfig(appPriv->clocksrchandle, OMX_IndexConfigTimeClockState, &sClockState);
01332     if(err!=OMX_ErrorNone) {
01333       DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig \n",err);
01334       exit(1);
01335     }
01336     err = OMX_GetConfig(appPriv->clocksrchandle, OMX_IndexConfigTimeClockState, &sClockState);
01337   }
01338 
01339   err = OMX_SendCommand(appPriv->videodechandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
01340   if(err != OMX_ErrorNone) {
01341     DEBUG(DEB_LEV_ERR,"video decoder state executing failed\n");
01342     exit(1);
01343   }
01344   tsem_down(appPriv->videoDecoderEventSem);
01345 
01346   err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
01347   if(err != OMX_ErrorNone) {
01348     DEBUG(DEB_LEV_ERR,"audio decoder state executing failed\n");
01349     exit(1);
01350   }
01351 
01352   /*Wait for decoder state change to executing*/
01353   tsem_down(appPriv->audioDecoderEventSem);
01354 
01355 
01356   if (flagIsDisplayRequested) {
01357     err = OMX_SendCommand(appPriv->colorconv_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
01358     if(err != OMX_ErrorNone) {
01359       DEBUG(DEB_LEV_ERR,"color converter state executing failed\n");
01360       exit(1);
01361     }
01362     DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for  color converter state executing\n");
01363     tsem_down(appPriv->colorconvEventSem);
01364 
01365     DEBUG(DEB_LEV_SIMPLE_SEQ,"sending video sink state to executing\n");
01366     err = OMX_SendCommand(appPriv->videosinkhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
01367     if(err != OMX_ErrorNone) {
01368       DEBUG(DEB_LEV_ERR,"video sink state executing failed\n");
01369       exit(1);
01370     }
01371     DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for  video sink state executing\n");
01372     tsem_down(appPriv->fbdevSinkEventSem);
01373     DEBUG(DEB_LEV_SIMPLE_SEQ, "video sink state executing successful\n");
01374 
01375     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
01376     if(err != OMX_ErrorNone) {
01377       DEBUG(DEB_LEV_ERR,"volume state executing failed\n");
01378       exit(1);
01379     }
01380     DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for  volume state executing\n");
01381     tsem_down(appPriv->volumeEventSem);
01382 
01383     DEBUG(DEB_LEV_SIMPLE_SEQ,"sending audio sink state executing\n");
01384     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
01385     if(err != OMX_ErrorNone) {
01386       DEBUG(DEB_LEV_ERR,"audio sink state executing failed\n");
01387       exit(1);
01388     }
01389     DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for  audio sink state executing\n");
01390     tsem_down(appPriv->audioSinkEventSem);
01391     DEBUG(DEB_LEV_SIMPLE_SEQ, "audio sink state executing successful\n");
01392   }
01393 
01394   DEBUG(DEFAULT_MESSAGES,"All Component state changed to Executing\n");
01395 
01396   if (!flagSetupTunnel)  {
01397     err = OMX_FillThisBuffer(appPriv->parser3gphandle, outBufferParseVideo[0]);
01398     if(err != OMX_ErrorNone) {
01399       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Parser3gp \n", __func__,err);
01400       exit(1);
01401     }
01402     DEBUG(DEB_LEV_PARAMS, "Fill parser second buffer %x\n", (int)outBufferParseVideo[1]);
01403     err = OMX_FillThisBuffer(appPriv->parser3gphandle, outBufferParseVideo[1]);
01404     if(err != OMX_ErrorNone) {
01405       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Parser3gp\n", __func__,err);
01406       exit(1);
01407     }
01408 
01409     err = OMX_FillThisBuffer(appPriv->parser3gphandle, outBufferParseAudio[0]);
01410     if(err != OMX_ErrorNone) {
01411       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Parser3gp \n", __func__,err);
01412       exit(1);
01413     }    
01414     DEBUG(DEB_LEV_PARAMS, "Fill parser second buffer %x\n", (int)outBufferParseAudio[1]);
01415     err = OMX_FillThisBuffer(appPriv->parser3gphandle, outBufferParseAudio[1]);
01416     if(err != OMX_ErrorNone) {
01417       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Parser3gp\n", __func__,err);
01418       exit(1);
01419     }    
01420 
01421     err = OMX_FillThisBuffer(appPriv->videodechandle, outBufferVideoDec[0]);
01422     if(err != OMX_ErrorNone) {
01423       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Video Dec\n", __func__,err);
01424       exit(1);
01425     }
01426     DEBUG(DEB_LEV_PARAMS, "Fill decoder second buffer %x\n", (int)outBufferVideoDec[1]);
01427     err = OMX_FillThisBuffer(appPriv->videodechandle, outBufferVideoDec[1]);
01428     if(err != OMX_ErrorNone) {
01429       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Video Dec\n", __func__,err);
01430       exit(1);
01431     }
01432 
01433     err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec[0]);
01434     if(err != OMX_ErrorNone) {
01435       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
01436       exit(1);
01437     }
01438     DEBUG(DEB_LEV_PARAMS, "Fill decoder second buffer %x\n", (int)outBufferAudioDec[1]);
01439     err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec[1]);
01440     if(err != OMX_ErrorNone) {
01441       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
01442       exit(1);
01443     }
01444 
01445     if (flagIsDisplayRequested) {
01446        err = OMX_FillThisBuffer(appPriv->colorconv_handle, outBufferColorconv[0]);
01447        if(err != OMX_ErrorNone) {
01448          DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Video Dec\n", __func__,err);
01449          exit(1);
01450        }
01451        DEBUG(DEB_LEV_PARAMS, "Fill decoder second buffer %x\n", (int)outBufferColorconv[1]);
01452        err = OMX_FillThisBuffer(appPriv->colorconv_handle, outBufferColorconv[1]);
01453        if(err != OMX_ErrorNone) {
01454          DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Video Dec\n", __func__,err);
01455          exit(1);
01456        }
01457 
01458        err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume[0]);
01459        if(err != OMX_ErrorNone) {
01460          DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
01461           exit(1);
01462        }
01463        DEBUG(DEB_LEV_PARAMS, "Fill decoder second buffer %x\n", (int)outBufferVolume[1]);
01464        err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume[1]);
01465        if(err != OMX_ErrorNone) {
01466          DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
01467          exit(1);
01468        }
01469      }
01470   }
01471 
01472   setHeader(&sConfigScale, sizeof(OMX_TIME_CONFIG_SCALETYPE));
01473   if(flagAVsync){
01474     DEBUG(DEFAULT_MESSAGES,"--------------------------\n");
01475     DEBUG(DEFAULT_MESSAGES,"Enter F : fastforward \n");
01476     DEBUG(DEFAULT_MESSAGES,"Enter R : Rewind      \n");
01477     DEBUG(DEFAULT_MESSAGES,"Enter P : Pause      \n");
01478     DEBUG(DEFAULT_MESSAGES,"Enter N : Normal Play      \n");
01479     DEBUG(DEFAULT_MESSAGES,"Enter Q : Quit       \n");
01480     DEBUG(DEFAULT_MESSAGES,"--------------------------\n");
01481     while(1) {
01482       keyin = toupper(getchar());
01483       if(keyin == 'Q'|| keyin == 'q'){
01484         DEBUG(DEFAULT_MESSAGES,"Quitting \n");
01485         bEOS = OMX_TRUE;
01486         break;
01487       }else{
01488         switch(keyin){
01489           case 'F':
01490           case 'f':
01491             newscale = 2<<16;    // Q16 format is used
01492             DEBUG(DEFAULT_MESSAGES,"Fast forwarding .......\n");
01493             break;
01494           case 'R':
01495           case 'r':
01496             newscale = -2<<16;    // Q16 format is used
01497             DEBUG(DEFAULT_MESSAGES,"Rewinding ........\n");
01498             break;
01499           case 'P':
01500           case 'p':
01501             newscale = 0;
01502             DEBUG(DEFAULT_MESSAGES,"Pause ......\n");
01503             break;
01504           case 'N':
01505           case 'n':
01506             newscale = 1<<16;    // Q16 format is used
01507             DEBUG(DEFAULT_MESSAGES,"Normal Play ......\n");
01508             break;
01509           default:
01510             break;        
01511         }
01512         sConfigScale.xScale = newscale;
01513        /* send the scale change notification to the clock */
01514         err = OMX_SetConfig(appPriv->clocksrchandle, OMX_IndexConfigTimeScale, &sConfigScale);
01515       }
01516     }
01517   }
01518 
01519   DEBUG(DEFAULT_MESSAGES,"Waiting for  EOS = %d\n",appPriv->eofSem->semval);
01520 
01521   tsem_down(appPriv->eofSem);
01522 
01523   DEBUG(DEFAULT_MESSAGES,"Received EOS \n");
01524   /*Send Idle Command to all components*/
01525   DEBUG(DEFAULT_MESSAGES, "The execution of the decoding process is terminated\n");
01526   err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01527   err = OMX_SendCommand(appPriv->videodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01528   err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01529 
01530 
01531   if (flagIsDisplayRequested) {
01532     err = OMX_SendCommand(appPriv->colorconv_handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01533     err = OMX_SendCommand(appPriv->videosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01534     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01535     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01536   }  
01537 
01538   if (flagAVsync) {
01539     err = OMX_SendCommand(appPriv->clocksrchandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
01540   }  
01541 
01542   tsem_down(appPriv->parser3gpEventSem);
01543   DEBUG(DEFAULT_MESSAGES,"Parser3gp idle state \n");
01544   tsem_down(appPriv->videoDecoderEventSem);
01545   tsem_down(appPriv->audioDecoderEventSem);
01546 
01547   if (flagIsDisplayRequested) {
01548     tsem_down(appPriv->colorconvEventSem);
01549     tsem_down(appPriv->volumeEventSem);
01550     tsem_down(appPriv->fbdevSinkEventSem);
01551     tsem_down(appPriv->audioSinkEventSem);
01552   }
01553 
01554   if (flagAVsync) {
01555     tsem_down(appPriv->clockEventSem);
01556   }  
01557 
01558   DEBUG(DEFAULT_MESSAGES, "All component Transitioned to Idle\n");
01559   /*Send Loaded Command to all components*/
01560   err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
01561   err = OMX_SendCommand(appPriv->videodechandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
01562   err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
01563 
01564   if (flagIsDisplayRequested) {
01565     err = OMX_SendCommand(appPriv->colorconv_handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
01566     err = OMX_SendCommand(appPriv->videosinkhandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
01567     err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
01568     err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
01569   }
01570 
01571   if (flagAVsync) {
01572     err = OMX_SendCommand(appPriv->clocksrchandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
01573   }  
01574 
01575   DEBUG(DEFAULT_MESSAGES, "All components to loaded\n");
01576 
01577   /*Free input buffers if components are not tunnelled*/
01578   if (!flagSetupTunnel) {
01579     err = OMX_FreeBuffer(appPriv->videodechandle, 0, inBufferVideoDec[0]);
01580     err = OMX_FreeBuffer(appPriv->videodechandle, 0, inBufferVideoDec[1]);
01581     err = OMX_FreeBuffer(appPriv->audiodechandle, 0, inBufferAudioDec[0]);
01582     err = OMX_FreeBuffer(appPriv->audiodechandle, 0, inBufferAudioDec[1]);
01583 
01584     DEBUG(DEB_LEV_PARAMS, "Freeing decoder output ports\n");
01585     err = OMX_FreeBuffer(appPriv->videodechandle, 1, outBufferVideoDec[0]);
01586     err = OMX_FreeBuffer(appPriv->videodechandle, 1, outBufferVideoDec[1]);
01587     err = OMX_FreeBuffer(appPriv->audiodechandle, 1, outBufferAudioDec[0]);
01588     err = OMX_FreeBuffer(appPriv->audiodechandle, 1, outBufferAudioDec[1]);
01589     err = OMX_FreeBuffer(appPriv->parser3gphandle, VIDEO_PORT_INDEX, outBufferParseVideo[0]);
01590     err = OMX_FreeBuffer(appPriv->parser3gphandle, VIDEO_PORT_INDEX, outBufferParseVideo[1]);
01591     err = OMX_FreeBuffer(appPriv->parser3gphandle, AUDIO_PORT_INDEX, outBufferParseAudio[0]);
01592     err = OMX_FreeBuffer(appPriv->parser3gphandle, AUDIO_PORT_INDEX, outBufferParseAudio[1]);
01593   }
01594 
01595   if (flagIsDisplayRequested && (!flagSetupTunnel)) {
01596     err = OMX_FreeBuffer(appPriv->colorconv_handle, 0, inBufferColorconv[0]);
01597     err = OMX_FreeBuffer(appPriv->colorconv_handle, 0, inBufferColorconv[1]);
01598     err = OMX_FreeBuffer(appPriv->colorconv_handle, 1, outBufferColorconv[0]);
01599     err = OMX_FreeBuffer(appPriv->colorconv_handle, 1, outBufferColorconv[1]);
01600 
01601     err = OMX_FreeBuffer(appPriv->volumehandle, 0, inBufferVolume[0]);
01602     err = OMX_FreeBuffer(appPriv->volumehandle, 0, inBufferVolume[1]);
01603     err = OMX_FreeBuffer(appPriv->volumehandle, 1, outBufferVolume[0]);
01604     err = OMX_FreeBuffer(appPriv->volumehandle, 1, outBufferVolume[1]);
01605 
01606     err = OMX_FreeBuffer(appPriv->videosinkhandle, 0, inBufferSinkVideo[0]);
01607     err = OMX_FreeBuffer(appPriv->videosinkhandle, 0, inBufferSinkVideo[1]);
01608     err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSinkAudio[0]);
01609     err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSinkAudio[1]);
01610   }
01611 
01612   tsem_down(appPriv->parser3gpEventSem);
01613   DEBUG(DEFAULT_MESSAGES,"Parser3gp loaded state \n");
01614   tsem_down(appPriv->videoDecoderEventSem); 
01615   tsem_down(appPriv->audioDecoderEventSem); 
01616 
01617   if (flagIsDisplayRequested) {
01618     tsem_down(appPriv->colorconvEventSem);
01619     tsem_down(appPriv->fbdevSinkEventSem);
01620     tsem_down(appPriv->volumeEventSem);
01621     tsem_down(appPriv->audioSinkEventSem);
01622   }
01623 
01624   if (flagAVsync) {
01625     tsem_down(appPriv->clockEventSem);
01626   }  
01627 
01628   DEBUG(DEFAULT_MESSAGES, "All components released\n");
01629 
01631   OMX_FreeHandle(appPriv->videodechandle);
01632   DEBUG(DEB_LEV_SIMPLE_SEQ, "videodec freed\n");
01633   OMX_FreeHandle(appPriv->audiodechandle);
01634   DEBUG(DEB_LEV_SIMPLE_SEQ, "audiodec dec freed\n");
01635 
01636   OMX_FreeHandle(appPriv->parser3gphandle);
01637   DEBUG(DEB_LEV_SIMPLE_SEQ, "parser3gp freed\n");
01638 
01639   if (flagIsDisplayRequested) {
01640     OMX_FreeHandle(appPriv->colorconv_handle);
01641     DEBUG(DEB_LEV_SIMPLE_SEQ, "color converter component freed\n");
01642     OMX_FreeHandle(appPriv->videosinkhandle);
01643     DEBUG(DEB_LEV_SIMPLE_SEQ, "videosink freed\n");
01644     OMX_FreeHandle(appPriv->volumehandle);
01645     DEBUG(DEB_LEV_SIMPLE_SEQ, "volume component freed\n");
01646     OMX_FreeHandle(appPriv->audiosinkhandle);
01647     DEBUG(DEB_LEV_SIMPLE_SEQ, "audiosink freed\n");
01648   }
01649 
01650   if (flagAVsync) {
01651     OMX_FreeHandle(appPriv->clocksrchandle);
01652     DEBUG(DEB_LEV_SIMPLE_SEQ, "clock src freed\n");
01653   }
01654 
01655   OMX_Deinit();
01656 
01657   DEBUG(DEB_LEV_SIMPLE_SEQ, "All components freed. Closing...\n");
01658 
01659   free(appPriv->parser3gpEventSem);
01660   appPriv->parser3gpEventSem = NULL;
01661 
01662   free(appPriv->videoDecoderEventSem);
01663   appPriv->videoDecoderEventSem = NULL;
01664   free(appPriv->audioDecoderEventSem);
01665   appPriv->audioDecoderEventSem = NULL;
01666 
01667   if (flagIsDisplayRequested) {
01668     free(appPriv->colorconvEventSem);
01669     appPriv->colorconvEventSem = NULL;
01670 
01671     free(appPriv->fbdevSinkEventSem);
01672     appPriv->fbdevSinkEventSem = NULL;
01673 
01674     free(appPriv->volumeEventSem);
01675     appPriv->volumeEventSem = NULL;
01676 
01677     free(appPriv->audioSinkEventSem);
01678     appPriv->audioSinkEventSem = NULL;
01679   }
01680 
01681   if(flagAVsync) {
01682     free(appPriv->clockEventSem);
01683   }
01684 
01685   free(appPriv->eofSem);
01686   appPriv->eofSem = NULL;
01687   free(appPriv);
01688   appPriv = NULL;
01689 
01690   if(!flagIsDisplayRequested) {
01691     fclose(outfileAudio);
01692     fclose(outfileVideo);
01693   }
01694 
01695   free(input_file);
01696   free(output_file_audio);
01697   free(output_file_video);
01698   free(temp);
01699 
01700   return 0;
01701 }  
01702 
01703 /* Callbacks implementation */
01704 OMX_ERRORTYPE parser3gpEventHandler(
01705   OMX_OUT OMX_HANDLETYPE hComponent,
01706   OMX_OUT OMX_PTR pAppData,
01707   OMX_OUT OMX_EVENTTYPE eEvent,
01708   OMX_OUT OMX_U32 Data1,
01709   OMX_OUT OMX_U32 Data2,
01710   OMX_OUT OMX_PTR pEventData)
01711 {
01712   OMX_PTR pExtraData;
01713   OMX_INDEXTYPE eIndexExtraData;
01714   OMX_ERRORTYPE err;
01715   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
01716 
01717   if(eEvent == OMX_EventCmdComplete) {
01718     if (Data1 == OMX_CommandStateSet) {
01719       DEBUG(DEB_LEV_SIMPLE_SEQ, "Parser 3gp State changed in ");
01720       switch ((int)Data2) {
01721       case OMX_StateInvalid:
01722         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
01723         break;
01724       case OMX_StateLoaded:
01725         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
01726         break;
01727       case OMX_StateIdle:
01728         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01729         break;
01730       case OMX_StateExecuting:
01731         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01732         break;
01733       case OMX_StatePause:
01734         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01735         break;
01736       case OMX_StateWaitForResources:
01737         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01738         break;
01739       }
01740       tsem_up(appPriv->parser3gpEventSem);
01741     } else if (Data1 == OMX_CommandPortEnable){
01742       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
01743       tsem_up(appPriv->parser3gpEventSem);
01744     } else if (Data1 == OMX_CommandPortDisable){
01745       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
01746       tsem_up(appPriv->parser3gpEventSem);
01747     } else if (Data1 == OMX_CommandFlush){
01748       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Flush Event\n",__func__);
01749       tsem_up(appPriv->parser3gpEventSem);
01750     } else {
01751       DEBUG(DEB_LEV_SIMPLE_SEQ,"In %s Received Event Event=%d Data1=%d,Data2=%d\n",__func__,eEvent,(int)Data1,(int)Data2);
01752     }
01753   }else if(eEvent == OMX_EventPortSettingsChanged) {
01754     DEBUG(DEB_LEV_SIMPLE_SEQ,"Parser3gp Port Setting Changed event\n");
01755 
01756     /* Passing the extra data to the video/audio decoder */
01757     if(Data2==0) { /* video port */
01758       err = OMX_GetExtensionIndex(appPriv->parser3gphandle,"OMX.ST.index.config.videoextradata",&eIndexExtraData);
01759       if(err != OMX_ErrorNone) {
01760         DEBUG(DEB_LEV_ERR,"\n 1 error in get extension index\n");
01761                           exit(1);
01762       } else {
01763         pExtraData = malloc(extradata_size);
01764         err = OMX_GetConfig(appPriv->parser3gphandle, eIndexExtraData, pExtraData);
01765         if(err != OMX_ErrorNone) {
01766           DEBUG(DEB_LEV_ERR,"\n parser 3gp Get Param Failed error =%08x index=%08x\n",err,eIndexExtraData);
01767                                   exit(1);
01768         }
01769         DEBUG(DEB_LEV_SIMPLE_SEQ,"Setting ExtraData\n");
01770         err = OMX_SetConfig(appPriv->videodechandle, eIndexExtraData, pExtraData);
01771         if(err != OMX_ErrorNone) {
01772           DEBUG(DEB_LEV_ERR,"\n video decoder Set Config Failed error=%08x\n",err);
01773                                   exit(1);
01774         }
01775         free(pExtraData);
01776       }    
01777     } else if (Data2==1) { /*audio port*/    
01778       err = OMX_GetExtensionIndex(appPriv->parser3gphandle,"OMX.ST.index.config.audioextradata",&eIndexExtraData);
01779       if(err != OMX_ErrorNone) {
01780         DEBUG(DEB_LEV_ERR,"\n 1 error in get extension index\n");
01781                           exit(1);
01782       } else {
01783         pExtraData = malloc(extradata_size);
01784         err = OMX_GetConfig(appPriv->parser3gphandle, eIndexExtraData, pExtraData);
01785         if(err != OMX_ErrorNone) {
01786           DEBUG(DEB_LEV_ERR,"\n parser 3gp Get Param Failed error =%08x index=%08x\n",err,eIndexExtraData);
01787                                   exit(1);
01788         }
01789         DEBUG(DEB_LEV_SIMPLE_SEQ,"Setting ExtraData\n");
01790         err = OMX_SetConfig(appPriv->audiodechandle, eIndexExtraData, pExtraData);
01791         if(err != OMX_ErrorNone) {
01792           DEBUG(DEB_LEV_ERR,"\n video decoder Set Config Failed error=%08x\n",err);
01793                                   exit(1);
01794         }
01795         free(pExtraData);
01796       }
01797    }
01798 
01799    /* In tunneled case disabling the ports of all the tunneled components */
01800    if (flagSetupTunnel) {
01801      if(Data2==0) { /* video port*/
01802          DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s parser3gp  Component Port Disabling\n", __func__);
01803         /*Sent Port Disable command. to disable both the output ports of the parser3gp */
01804         err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandPortDisable, VIDEO_PORT_INDEX, NULL);
01805         if(err != OMX_ErrorNone) {
01806           DEBUG(DEB_LEV_ERR,"parser3gp video port disable failed\n");
01807           exit(1);
01808         }
01809          DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Video decoder Component Port Disabling\n", __func__);
01810         /*Sent Port Disable command. to disable dec, colorconv, sink ports before setting port their parameters */
01811         err = OMX_SendCommand(appPriv->videodechandle, OMX_CommandPortDisable, OMX_ALL, NULL);
01812         if(err != OMX_ErrorNone) {
01813           DEBUG(DEB_LEV_ERR,"Video decoder port disable failed err=%08x\n",err);
01814           exit(1);
01815         }
01816 
01817        if(flagIsDisplayRequested){
01818          DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Color Converter Component Port Disabling\n", __func__);
01819           err = OMX_SendCommand(appPriv->colorconv_handle, OMX_CommandPortDisable, OMX_ALL, NULL);
01820           if(err != OMX_ErrorNone) {
01821             DEBUG(DEB_LEV_ERR,"Color Converter Component port disable failed\n");
01822             exit(1);
01823           }
01824 
01825           DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Video Sink Port Disabling\n", __func__);
01826           err = OMX_SendCommand(appPriv->videosinkhandle, OMX_CommandPortDisable, 0, NULL);
01827           if(err != OMX_ErrorNone) {
01828             DEBUG(DEB_LEV_ERR,"video sink port disable failed\n");
01829             exit(1);
01830           }
01831        }
01832      }else if (Data2==1) { /* audio port */
01833 
01834          DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s parser3gp  Component Port Disabling\n", __func__);
01835         /*Sent Port Disable command. to disable both the output ports of the parser3gp */
01836         err = OMX_SendCommand(appPriv->parser3gphandle, OMX_CommandPortDisable, AUDIO_PORT_INDEX, NULL);
01837         if(err != OMX_ErrorNone) {
01838           DEBUG(DEB_LEV_ERR,"parser3gp audio port disable failed\n");
01839           exit(1);
01840         }
01841 
01842         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio decoder Component Port Disabling\n", __func__);
01843         /*Sent Port Disable command. to disable audio dec, volume and audio sink ports before setting port their parameters */
01844         err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandPortDisable, OMX_ALL, NULL);
01845         if(err != OMX_ErrorNone) {
01846           DEBUG(DEB_LEV_ERR,"Audio decoder port disable failed\n");
01847           exit(1);
01848         }
01849 
01850        if(flagIsDisplayRequested){
01851          DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Volume Component Port Disabling\n", __func__);
01852           err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortDisable, OMX_ALL, NULL);
01853           if(err != OMX_ErrorNone) {
01854             DEBUG(DEB_LEV_ERR,"Volume Component port disable failed\n");
01855             exit(1);
01856           }
01857   
01858           DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Port Disabling\n", __func__);
01859           err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortDisable, 0, NULL);
01860           if(err != OMX_ErrorNone) {
01861             DEBUG(DEB_LEV_ERR,"Audio sink port disable failed\n");
01862             exit(1);
01863           }
01864        }
01865     }
01866    }
01867    /*Signal Port Setting Changed*/
01868    tsem_up(appPriv->parser3gpEventSem);
01869   }else if(eEvent == OMX_EventPortFormatDetected) {
01870     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Port Format Detected %x\n", __func__,(int)Data1);
01871   }else if (eEvent ==OMX_EventError){
01872     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Error in %x Detection for port %d\n",__func__,(int)Data1,(int)Data2);
01873   } else if(eEvent == OMX_EventBufferFlag) {
01874     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
01875     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
01876     }
01877   } else {
01878     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01879     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01880   }
01881   return OMX_ErrorNone;
01882 }
01883 
01884 OMX_ERRORTYPE parser3gpFillBufferDone(
01885   OMX_OUT OMX_HANDLETYPE hComponent,
01886   OMX_OUT OMX_PTR pAppData,
01887   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01888 {
01889   OMX_ERRORTYPE err;
01890   /* Output data to video & audio decoder */
01891   
01892   if(pBuffer != NULL){
01893     switch(pBuffer->nOutputPortIndex) {
01894     case VIDEO_PORT_INDEX:
01895       if(!bEOS) {
01896         if(inBufferVideoDec[0]->pBuffer == pBuffer->pBuffer) {
01897           inBufferVideoDec[0]->nFilledLen = pBuffer->nFilledLen;
01898           inBufferVideoDec[0]->nTimeStamp = pBuffer->nTimeStamp;
01899           if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
01900             inBufferVideoDec[0]->nFlags = pBuffer->nFlags;
01901             pBuffer->nFlags             = 0;
01902           }
01903           err = OMX_EmptyThisBuffer(appPriv->videodechandle, inBufferVideoDec[0]);
01904         } else {
01905           inBufferVideoDec[1]->nFilledLen = pBuffer->nFilledLen;
01906           inBufferVideoDec[1]->nTimeStamp = pBuffer->nTimeStamp;
01907           if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
01908             inBufferVideoDec[1]->nFlags = pBuffer->nFlags;
01909             pBuffer->nFlags             = 0;
01910           }
01911           err = OMX_EmptyThisBuffer(appPriv->videodechandle, inBufferVideoDec[1]);
01912         }
01913         if(err != OMX_ErrorNone) {
01914           DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01915         }
01916         if(pBuffer->nFlags==OMX_BUFFERFLAG_EOS) {
01917           DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Calling Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
01918           bEOS=OMX_TRUE;
01919         }
01920       } else {
01921         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
01922       }
01923       break;
01924      case AUDIO_PORT_INDEX:
01925        if(!bEOS) {
01926          if(inBufferAudioDec[0]->pBuffer == pBuffer->pBuffer) {
01927            inBufferAudioDec[0]->nFilledLen = pBuffer->nFilledLen;
01928            inBufferAudioDec[0]->nTimeStamp = pBuffer->nTimeStamp;
01929           if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
01930             inBufferAudioDec[0]->nFlags = pBuffer->nFlags;
01931             pBuffer->nFlags             = 0;
01932           }
01933            err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec[0]);
01934          } else {
01935            inBufferAudioDec[1]->nFilledLen = pBuffer->nFilledLen;
01936            inBufferAudioDec[1]->nTimeStamp = pBuffer->nTimeStamp;
01937           if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
01938             inBufferAudioDec[1]->nFlags = pBuffer->nFlags;
01939             pBuffer->nFlags             = 0;
01940           }
01941            err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec[1]);
01942          }
01943          if(err != OMX_ErrorNone) {
01944            DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01945          }
01946          if(pBuffer->nFlags==OMX_BUFFERFLAG_EOS) {
01947            DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Calling Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
01948            bEOS=OMX_TRUE;
01949          }
01950        } else {
01951          DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
01952        }
01953        break;
01954      }
01955    }  else {
01956     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01957    }
01958   return OMX_ErrorNone;
01959 }
01960 
01961 OMX_ERRORTYPE videodecEventHandler(
01962   OMX_OUT OMX_HANDLETYPE hComponent,
01963   OMX_OUT OMX_PTR pAppData,
01964   OMX_OUT OMX_EVENTTYPE eEvent,
01965   OMX_OUT OMX_U32 Data1,
01966   OMX_OUT OMX_U32 Data2,
01967   OMX_OUT OMX_PTR pEventData)
01968 {
01969   OMX_ERRORTYPE err;
01970   OMX_PARAM_PORTDEFINITIONTYPE param;
01971   
01972   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback\n", __func__);
01973   if(eEvent == OMX_EventCmdComplete) {
01974     if (Data1 == OMX_CommandStateSet) {
01975       DEBUG(DEB_LEV_SIMPLE_SEQ/*SIMPLE_SEQ*/, "Video Decoder State changed in ");
01976       switch ((int)Data2) {
01977       case OMX_StateInvalid:
01978         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
01979         break;
01980       case OMX_StateLoaded:
01981         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
01982         break;
01983       case OMX_StateIdle:
01984         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01985         break;
01986       case OMX_StateExecuting:
01987         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01988         break;
01989       case OMX_StatePause:
01990         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01991         break;
01992       case OMX_StateWaitForResources:
01993         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01994         break;
01995       }
01996       tsem_up(appPriv->videoDecoderEventSem);
01997     }
01998     else if (Data1 == OMX_CommandPortEnable){
01999       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
02000       tsem_up(appPriv->videoDecoderEventSem);
02001     } else if (Data1 == OMX_CommandPortDisable){
02002       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
02003       tsem_up(appPriv->videoDecoderEventSem);
02004     } else if (Data1 == OMX_CommandFlush){
02005       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Flush Event\n",__func__);
02006       tsem_up(appPriv->videoDecoderEventSem);
02007     } 
02008   } else if(eEvent == OMX_EventPortSettingsChanged) {
02009     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Settings Changed Event\n", __func__);
02010     if (Data2 == 1) {
02011       param.nPortIndex = 1;
02012       setHeader(&param, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
02013       err = OMX_GetParameter(appPriv->videodechandle,OMX_IndexParamPortDefinition, &param);
02014       /*Get Port parameters*/
02015     } else if (Data2 == 0) {
02016       /*Get Port parameters*/
02017       param.nPortIndex = 0;
02018       setHeader(&param, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
02019       err = OMX_GetParameter(appPriv->videodechandle,OMX_IndexParamPortDefinition, &param);
02020     }
02021   } else if(eEvent == OMX_EventBufferFlag) {
02022     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
02023     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
02024     }
02025   } else {
02026     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
02027     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
02028   }
02029   
02030   return OMX_ErrorNone;
02031 }
02032 
02033 OMX_ERRORTYPE videodecEmptyBufferDone(
02034   OMX_OUT OMX_HANDLETYPE hComponent,
02035   OMX_OUT OMX_PTR pAppData,
02036   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
02037 {
02038   OMX_ERRORTYPE err;
02039   static int iBufferDropped=0;
02040   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
02041 
02042     if(pBuffer != NULL){
02043       if(!bEOS) {
02044         if(outBufferParseVideo[0]->pBuffer == pBuffer->pBuffer) {
02045           outBufferParseVideo[0]->nFilledLen=0;
02046           err = OMX_FillThisBuffer(appPriv->parser3gphandle, outBufferParseVideo[0]);
02047         } else {
02048           outBufferParseVideo[1]->nFilledLen=0;
02049           err = OMX_FillThisBuffer(appPriv->parser3gphandle, outBufferParseVideo[1]);
02050         }
02051         if(err != OMX_ErrorNone) {
02052           DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02053         }
02054       }
02055       else {
02056         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
02057         iBufferDropped++;
02058         if(iBufferDropped==2) {
02059 //          tsem_up(appPriv->eofSem);
02060         }
02061       }
02062     } else {
02063       if(!bEOS) {
02064         DEBUG(DEB_LEV_SIMPLE_SEQ,"It is here EOS = %d\n",appPriv->eofSem->semval);
02065       }
02066       DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02067     }
02068   return OMX_ErrorNone;
02069 }
02070 
02071 OMX_ERRORTYPE videodecFillBufferDone(
02072   OMX_OUT OMX_HANDLETYPE hComponent,
02073   OMX_OUT OMX_PTR pAppData,
02074   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
02075 {
02076   OMX_ERRORTYPE err;
02077   int i;
02078   DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__);
02079   /* Output data to alsa sink */
02080   if(pBuffer != NULL){
02081    if(!bEOS) {
02082     if (pBuffer->nFilledLen == 0) {
02083       DEBUG(DEB_LEV_ERR, "Gadbadax! In %s: had 0 data size in output buffer...\n", __func__);
02084       return OMX_ErrorNone;
02085     }
02086     if ((!flagDecodedOutputReceived)  && (!flagIsDisplayRequested) ) {
02087       for(i = 0; i<pBuffer->nFilledLen; i++){
02088         putchar(*(char*)(pBuffer->pBuffer + i));
02089       }
02090       pBuffer->nFilledLen = 0;
02091       err = OMX_FillThisBuffer(hComponent, pBuffer);
02092       if(err != OMX_ErrorNone) {
02093         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02094       }
02095     } else if ((flagDecodedOutputReceived) && (!flagIsDisplayRequested)) {
02096       if(pBuffer->nFilledLen > 0) {
02097         fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfileVideo);
02098       }
02099       pBuffer->nFilledLen = 0;
02100       err = OMX_FillThisBuffer(hComponent, pBuffer);
02101       if(err != OMX_ErrorNone) {
02102         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02103       }
02104     }
02105       else if ((!flagSetupTunnel) && (flagIsDisplayRequested))  { //colorconverter on, redirect to sink, if it is not tunneled
02106       if(inBufferColorconv[0]->pBuffer == pBuffer->pBuffer) {
02107         inBufferColorconv[0]->nFilledLen = pBuffer->nFilledLen;
02108         inBufferColorconv[0]->nTimeStamp = pBuffer->nTimeStamp;
02109         if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
02110           inBufferColorconv[0]->nFlags = pBuffer->nFlags;
02111           pBuffer->nFlags              = 0;
02112         }
02113         err = OMX_EmptyThisBuffer(appPriv->colorconv_handle, inBufferColorconv[0]);
02114       } else {
02115         inBufferColorconv[1]->nFilledLen = pBuffer->nFilledLen;
02116         inBufferColorconv[1]->nTimeStamp = pBuffer->nTimeStamp;
02117         if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
02118           inBufferColorconv[1]->nFlags = pBuffer->nFlags;
02119           pBuffer->nFlags              = 0;
02120         }
02121         err = OMX_EmptyThisBuffer(appPriv->colorconv_handle, inBufferColorconv[1]);
02122       }
02123       if(err != OMX_ErrorNone) {
02124         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling EmptyThisBuffer\n", __func__,err);
02125       }
02126     }
02127    } else {
02128         DEBUG(DEB_LEV_ERR, " Buffer Dropping ...\n");
02129    }
02130   }  else {
02131     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02132   }
02133   return OMX_ErrorNone;
02134 }
02135 
02136 /* Callbacks implementation of the color conv component */
02137 OMX_ERRORTYPE colorconvEventHandler(
02138   OMX_OUT OMX_HANDLETYPE hComponent,
02139   OMX_OUT OMX_PTR pAppData,
02140   OMX_OUT OMX_EVENTTYPE eEvent,
02141   OMX_OUT OMX_U32 Data1,
02142   OMX_OUT OMX_U32 Data2,
02143   OMX_OUT OMX_PTR pEventData) {
02144 
02145   DEBUG(DEB_LEV_SIMPLE_SEQ, "\nHi there, I am in the %s callback\n", __func__);
02146   if(eEvent == OMX_EventCmdComplete) {
02147     if (Data1 == OMX_CommandStateSet) {
02148       DEBUG(DEB_LEV_SIMPLE_SEQ, "\nState changed in ");
02149       switch ((int)Data2) {
02150         case OMX_StateInvalid:
02151           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
02152           break;
02153         case OMX_StateLoaded:
02154           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
02155           break;
02156         case OMX_StateIdle:
02157           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
02158           break;
02159         case OMX_StateExecuting:
02160           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
02161           break;
02162         case OMX_StatePause:
02163           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
02164           break;
02165         case OMX_StateWaitForResources:
02166           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
02167           break;
02168       }
02169       tsem_up(appPriv->colorconvEventSem);
02170     } else if (OMX_CommandPortEnable || OMX_CommandPortDisable) {
02171       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable/Disable Event\n",__func__);
02172       tsem_up(appPriv->colorconvEventSem);
02173     } else if (OMX_CommandFlush){
02174       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Flush Event\n",__func__);
02175       tsem_up(appPriv->colorconvEventSem);
02176     }
02177   } else if(eEvent == OMX_EventBufferFlag) {
02178     DEBUG(DEB_LEV_ERR, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
02179     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
02180 //      tsem_up(appPriv->eofSem);
02181     }
02182   } else {
02183     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
02184     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
02185   }
02186   return OMX_ErrorNone;
02187 }
02188 
02189 OMX_ERRORTYPE colorconvEmptyBufferDone(
02190   OMX_OUT OMX_HANDLETYPE hComponent,
02191   OMX_OUT OMX_PTR pAppData,
02192   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) {
02193 
02194   OMX_ERRORTYPE err;
02195   static int iBufferDropped = 0;
02196 
02197   if(pBuffer != NULL) {
02198     if(!bEOS) {
02199       if(outBufferVideoDec[0]->pBuffer == pBuffer->pBuffer) {
02200         outBufferVideoDec[0]->nFilledLen = pBuffer->nFilledLen;
02201         err = OMX_FillThisBuffer(appPriv->videodechandle, outBufferVideoDec[0]);
02202       } else {
02203         outBufferVideoDec[1]->nFilledLen = pBuffer->nFilledLen;
02204         err = OMX_FillThisBuffer(appPriv->videodechandle, outBufferVideoDec[1]);
02205       }
02206       if(err != OMX_ErrorNone) {
02207         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02208       }
02209     } else {
02210       DEBUG(DEB_LEV_ERR, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
02211       iBufferDropped++;
02212       if(iBufferDropped == 2) {
02213 //        tsem_up(appPriv->eofSem);
02214       }
02215     }
02216   } else {
02217     if(!bEOS) {
02218 //      tsem_up(appPriv->eofSem);
02219     }
02220     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02221   }
02222   return OMX_ErrorNone;
02223 }
02224 
02225 OMX_ERRORTYPE colorconvFillBufferDone(
02226   OMX_OUT OMX_HANDLETYPE hComponent,
02227   OMX_OUT OMX_PTR pAppData,
02228   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) {
02229 
02230   OMX_ERRORTYPE err;
02231   if(pBuffer != NULL) {
02232     if(!bEOS) {
02236       if(flagIsDisplayRequested && (!flagSetupTunnel)) {
02237         if(inBufferSinkVideo[0]->pBuffer == pBuffer->pBuffer) {
02238           inBufferSinkVideo[0]->nFilledLen = pBuffer->nFilledLen;
02239           inBufferSinkVideo[0]->nTimeStamp = pBuffer->nTimeStamp;
02240           if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
02241             inBufferSinkVideo[0]->nFlags = pBuffer->nFlags;
02242             pBuffer->nFlags              = 0;
02243           }
02244           err = OMX_EmptyThisBuffer(appPriv->videosinkhandle, inBufferSinkVideo[0]);
02245         } else {
02246           inBufferSinkVideo[1]->nFilledLen = pBuffer->nFilledLen;
02247           inBufferSinkVideo[1]->nTimeStamp = pBuffer->nTimeStamp;
02248           if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
02249             inBufferSinkVideo[1]->nFlags = pBuffer->nFlags;
02250             pBuffer->nFlags              = 0;
02251           }
02252           err = OMX_EmptyThisBuffer(appPriv->videosinkhandle, inBufferSinkVideo[1]);
02253         }
02254         if(err != OMX_ErrorNone) {
02255           DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02256         }
02257       } else if((pBuffer->nFilledLen > 0) && (!flagSetupTunnel)) {
02258           fwrite(pBuffer->pBuffer, sizeof(char),  pBuffer->nFilledLen, outfileVideo);
02259           pBuffer->nFilledLen = 0;
02260       }
02261       if(pBuffer->nFlags == OMX_BUFFERFLAG_EOS) {
02262         DEBUG(DEB_LEV_ERR, "In %s: eos=%x Calling Empty This Buffer\n", __func__, (int)pBuffer->nFlags);
02263         bEOS = OMX_TRUE;
02264       }
02265       if(!bEOS && !flagIsDisplayRequested && (!flagSetupTunnel)) {
02266         err = OMX_FillThisBuffer(hComponent, pBuffer);
02267       }
02268     } else {
02269       DEBUG(DEB_LEV_ERR, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
02270     }
02271   } else {
02272     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02273   }
02274   return OMX_ErrorNone;
02275 }
02276 
02278 OMX_ERRORTYPE fb_sinkEventHandler(
02279   OMX_OUT OMX_HANDLETYPE hComponent,
02280   OMX_OUT OMX_PTR pAppData,
02281   OMX_OUT OMX_EVENTTYPE eEvent,
02282   OMX_OUT OMX_U32 Data1,
02283   OMX_OUT OMX_U32 Data2,
02284   OMX_OUT OMX_PTR pEventData) {
02285 
02286   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
02287   if(eEvent == OMX_EventCmdComplete) {
02288     if (Data1 == OMX_CommandStateSet) {
02289       DEBUG(DEB_LEV_SIMPLE_SEQ, "State changed in ");
02290       switch ((int)Data2) {
02291         case OMX_StateInvalid:
02292           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
02293           break;
02294         case OMX_StateLoaded:
02295           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
02296           break;
02297         case OMX_StateIdle:
02298           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle ---- fbsink\n");
02299           break;
02300         case OMX_StateExecuting:
02301           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
02302           break;
02303         case OMX_StatePause:
02304           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
02305           break;
02306         case OMX_StateWaitForResources:
02307           DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
02308           break;
02309       }
02310       tsem_up(appPriv->fbdevSinkEventSem);
02311     } else if (OMX_CommandPortEnable || OMX_CommandPortDisable) {
02312       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable/Disable Event\n",__func__);
02313       tsem_up(appPriv->fbdevSinkEventSem);
02314     } else if (OMX_CommandFlush){
02315       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Flush Event\n",__func__);
02316       tsem_up(appPriv->fbdevSinkEventSem);
02317     }
02318   } else if(eEvent == OMX_EventBufferFlag) {
02319     DEBUG(DEB_LEV_ERR, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
02320     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
02321       tsem_up(appPriv->eofSem);
02322     }
02323   } else {
02324     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
02325     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
02326   }
02327   return OMX_ErrorNone;
02328 }
02329 
02330 OMX_ERRORTYPE fb_sinkEmptyBufferDone(
02331   OMX_OUT OMX_HANDLETYPE hComponent,
02332   OMX_OUT OMX_PTR pAppData,
02333   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) {
02334 
02335   OMX_ERRORTYPE err;
02336   static int inputBufferDropped = 0;
02337   if(pBuffer != NULL) {
02338     if(!bEOS) {
02339       if(outBufferColorconv[0]->pBuffer == pBuffer->pBuffer) {
02340         outBufferColorconv[0]->nFilledLen = pBuffer->nFilledLen;
02341         err = OMX_FillThisBuffer(appPriv->colorconv_handle, outBufferColorconv[0]);
02342       } else {
02343         outBufferColorconv[1]->nFilledLen = pBuffer->nFilledLen;
02344         err = OMX_FillThisBuffer(appPriv->colorconv_handle, outBufferColorconv[1]);
02345       }
02346       if(err != OMX_ErrorNone) {
02347         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02348       }
02349     } else {
02350       DEBUG(DEB_LEV_ERR, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
02351       inputBufferDropped++;
02352       if(inputBufferDropped == 2) {
02353         tsem_up(appPriv->eofSem);
02354       }
02355     }
02356   } else {
02357     if(!bEOS) {
02358       tsem_up(appPriv->eofSem);
02359     }
02360     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02361   }
02362   return OMX_ErrorNone;
02363 }
02364 
02365 OMX_ERRORTYPE audiodecEventHandler(
02366   OMX_OUT OMX_HANDLETYPE hComponent,
02367   OMX_OUT OMX_PTR pAppData,
02368   OMX_OUT OMX_EVENTTYPE eEvent,
02369   OMX_OUT OMX_U32 Data1,
02370   OMX_OUT OMX_U32 Data2,
02371   OMX_OUT OMX_PTR pEventData)
02372 {
02373   OMX_ERRORTYPE err;
02374   OMX_PARAM_PORTDEFINITIONTYPE param;
02375 //  OMX_AUDIO_PARAM_PCMMODETYPE pcmParam;
02376 
02377   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
02378   if(eEvent == OMX_EventCmdComplete) {
02379     if (Data1 == OMX_CommandStateSet) {
02380       DEBUG(DEB_LEV_SIMPLE_SEQ/*SIMPLE_SEQ*/, "Audio Decoder State changed in ");
02381       switch ((int)Data2) {
02382       case OMX_StateInvalid:
02383         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
02384         break;
02385       case OMX_StateLoaded:
02386         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
02387         break;
02388       case OMX_StateIdle:
02389         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
02390         break;
02391       case OMX_StateExecuting:
02392         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
02393         break;
02394       case OMX_StatePause:
02395         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
02396         break;
02397       case OMX_StateWaitForResources:
02398         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
02399         break;
02400       }
02401       tsem_up(appPriv->audioDecoderEventSem);
02402     }
02403     else if (Data1 == OMX_CommandPortEnable){
02404       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
02405       tsem_up(appPriv->audioDecoderEventSem);
02406     } else if (Data1 == OMX_CommandPortDisable){
02407       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
02408       tsem_up(appPriv->audioDecoderEventSem);
02409     } else if (Data1 == OMX_CommandFlush){
02410       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Flush Event\n",__func__);
02411       tsem_up(appPriv->audioDecoderEventSem);
02412     }
02413   } else if(eEvent == OMX_EventPortSettingsChanged) {
02414     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Settings Changed Event\n", __func__);
02415     if (Data2 == 1) {
02416       param.nPortIndex = 1;
02417       setHeader(&param, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
02418       err = OMX_GetParameter(appPriv->audiodechandle,OMX_IndexParamPortDefinition, &param);
02419     } else if (Data2 == 0) {
02420       /*Get Port parameters*/
02421       param.nPortIndex = 0;
02422       setHeader(&param, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
02423       err = OMX_GetParameter(appPriv->audiodechandle,OMX_IndexParamPortDefinition, &param);
02424     }
02425   } else if(eEvent == OMX_EventBufferFlag) {
02426     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
02427     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
02428 //      tsem_up(appPriv->eofSem);
02429     }
02430   } else {
02431     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
02432     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
02433   }
02434 
02435   return OMX_ErrorNone;
02436 }
02437 
02438 OMX_ERRORTYPE audiodecEmptyBufferDone(
02439   OMX_OUT OMX_HANDLETYPE hComponent,
02440   OMX_OUT OMX_PTR pAppData,
02441   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
02442 {
02443   OMX_ERRORTYPE err;
02444   static int iBufferDropped=0;
02445   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
02446 
02447     if(pBuffer != NULL){
02448       if(!bEOS) {
02449         if(outBufferParseAudio[0]->pBuffer == pBuffer->pBuffer) {
02450           outBufferParseAudio[0]->nFilledLen=0;
02451           err = OMX_FillThisBuffer(appPriv->parser3gphandle, outBufferParseAudio[0]);
02452         } else {
02453           outBufferParseAudio[1]->nFilledLen=0;
02454           err = OMX_FillThisBuffer(appPriv->parser3gphandle, outBufferParseAudio[1]);
02455         }
02456         if(err != OMX_ErrorNone) {
02457           DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02458         }
02459       }
02460       else {
02461         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
02462         iBufferDropped++;
02463         if(iBufferDropped==2) {
02464 //          tsem_up(appPriv->eofSem);
02465         }
02466       }
02467     } else {
02468       if(!bEOS) {
02469         DEBUG(DEB_LEV_SIMPLE_SEQ,"It is here EOS = %d\n",appPriv->eofSem->semval);
02470 //        tsem_up(appPriv->eofSem);
02471       }
02472       DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02473     }
02474   return OMX_ErrorNone;
02475 }
02476 
02477 OMX_ERRORTYPE audiodecFillBufferDone(
02478   OMX_OUT OMX_HANDLETYPE hComponent,
02479   OMX_OUT OMX_PTR pAppData,
02480   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
02481 {
02482   OMX_ERRORTYPE err;
02483   int i;
02484   DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__);
02485   /* Output data to alsa sink */
02486   if(pBuffer != NULL){
02487    if(!bEOS) {
02488     if (pBuffer->nFilledLen == 0) {
02489       DEBUG(DEB_LEV_ERR, "Ouch! In %s: had 0 data size in output buffer...\n", __func__);
02490       return OMX_ErrorNone;
02491     }
02492     if ((!flagDecodedOutputReceived)  && (!flagIsDisplayRequested)/*(!flagOutputReceived) && (!flagPlaybackOn) && (flagDirect)*/) {
02493       for(i = 0; i<pBuffer->nFilledLen; i++){
02494         putchar(*(char*)(pBuffer->pBuffer + i));
02495       }
02496       pBuffer->nFilledLen = 0;
02497       err = OMX_FillThisBuffer(hComponent, pBuffer);
02498       if(err != OMX_ErrorNone) {
02499         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02500       }
02501     } else if ((flagDecodedOutputReceived) && (!flagIsDisplayRequested)) {
02502       if(pBuffer->nFilledLen > 0) {
02503         fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfileAudio);
02504       }
02505       pBuffer->nFilledLen = 0;
02506       err = OMX_FillThisBuffer(hComponent, pBuffer);
02507       if(err != OMX_ErrorNone) {
02508         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02509       }
02510     } else if ((!flagSetupTunnel) && (flagIsDisplayRequested))  { //playback on, redirect to alsa sink, if it is not tunneled
02511       if(inBufferVolume[0]->pBuffer == pBuffer->pBuffer) {
02512         inBufferVolume[0]->nFilledLen = pBuffer->nFilledLen;
02513         inBufferVolume[0]->nTimeStamp = pBuffer->nTimeStamp;
02514         if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
02515           inBufferVolume[0]->nFlags = pBuffer->nFlags;
02516           pBuffer->nFlags           = 0;
02517         }
02518         err = OMX_EmptyThisBuffer(appPriv->volumehandle, inBufferVolume[0]);
02519       } else {
02520         inBufferVolume[1]->nFilledLen = pBuffer->nFilledLen;
02521         inBufferVolume[1]->nTimeStamp = pBuffer->nTimeStamp;
02522         if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
02523           inBufferVolume[1]->nFlags = pBuffer->nFlags;
02524           pBuffer->nFlags           = 0;
02525         }
02526         err = OMX_EmptyThisBuffer(appPriv->volumehandle, inBufferVolume[1]);
02527       }
02528       if(err != OMX_ErrorNone) {
02529         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling EmptyThisBuffer\n", __func__,err);
02530       }
02531     }
02532    } else {
02533         DEBUG(DEB_LEV_ERR, " Buffer Dropping ...\n");
02534    }
02535   }     else {
02536     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02537   }
02538   return OMX_ErrorNone;
02539 }
02540 
02541 OMX_ERRORTYPE volumeEventHandler(
02542   OMX_OUT OMX_HANDLETYPE hComponent,
02543   OMX_OUT OMX_PTR pAppData,
02544   OMX_OUT OMX_EVENTTYPE eEvent,
02545   OMX_OUT OMX_U32 Data1,
02546   OMX_OUT OMX_U32 Data2,
02547   OMX_OUT OMX_PTR pEventData)
02548 {
02549 
02550   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
02551   if(eEvent == OMX_EventCmdComplete) {
02552     if (Data1 == OMX_CommandStateSet) {
02553       DEBUG(DEB_LEV_SIMPLE_SEQ/*SIMPLE_SEQ*/, "Audio Decoder State changed in ");
02554       switch ((int)Data2) {
02555       case OMX_StateInvalid:
02556         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
02557         break;
02558       case OMX_StateLoaded:
02559         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
02560         break;
02561       case OMX_StateIdle:
02562         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
02563         break;
02564       case OMX_StateExecuting:
02565         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
02566         break;
02567       case OMX_StatePause:
02568         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
02569         break;
02570       case OMX_StateWaitForResources:
02571         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
02572         break;
02573       }
02574       tsem_up(appPriv->volumeEventSem);
02575     } else  if (Data1 == OMX_CommandPortEnable){
02576       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
02577       tsem_up(appPriv->volumeEventSem);
02578     } else if (Data1 == OMX_CommandPortDisable){
02579       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
02580       tsem_up(appPriv->volumeEventSem);
02581     } else if (Data1 == OMX_CommandFlush){
02582       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Flush Event\n",__func__);
02583       tsem_up(appPriv->volumeEventSem);
02584     }
02585   } else if(eEvent == OMX_EventBufferFlag) {
02586     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
02587     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
02588 //      tsem_up(appPriv->eofSem);
02589     }
02590   } else {
02591     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
02592     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
02593   }
02594 
02595   return OMX_ErrorNone;
02596 }
02597 OMX_ERRORTYPE volumeEmptyBufferDone(
02598   OMX_OUT OMX_HANDLETYPE hComponent,
02599   OMX_OUT OMX_PTR pAppData,
02600   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
02601 {
02602   OMX_ERRORTYPE err;
02603   static int iBufferDropped=0;
02604   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
02605 
02606   if(pBuffer != NULL){
02607     if(!bEOS) {
02608       if(outBufferAudioDec[0]->pBuffer == pBuffer->pBuffer) {
02609         outBufferAudioDec[0]->nFilledLen=0;
02610         err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec[0]);
02611       } else {
02612         outBufferAudioDec[1]->nFilledLen=0;
02613         err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec[1]);
02614       }
02615       if(err != OMX_ErrorNone) {
02616         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02617       }
02618     }
02619     else {
02620       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
02621       iBufferDropped++;
02622       if(iBufferDropped==2) {
02623 //        tsem_up(appPriv->eofSem);
02624       }
02625     }
02626   } else {
02627     if(!bEOS) {
02628       DEBUG(DEFAULT_MESSAGES,"It is here EOS = %d\n",appPriv->eofSem->semval);
02629 //      tsem_up(appPriv->eofSem);
02630     }
02631     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02632   }
02633   return OMX_ErrorNone;
02634 }
02635 
02636 OMX_ERRORTYPE volumeFillBufferDone(
02637   OMX_OUT OMX_HANDLETYPE hComponent,
02638   OMX_OUT OMX_PTR pAppData,
02639   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
02640 {
02641   OMX_ERRORTYPE err;
02642   int i;
02643   static int volCompBufferDropped=0;
02644   DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__);
02645   /* Output data to alsa sink */
02646   if(pBuffer != NULL){
02647     if (pBuffer->nFilledLen == 0) {
02648       DEBUG(DEB_LEV_ERR, "Ouch! In %s: had 0 data size in output buffer...\n", __func__);
02649       return OMX_ErrorNone;
02650     }
02651     if ((!flagDecodedOutputReceived)  && (!flagIsDisplayRequested)) {
02652       for(i = 0; i<pBuffer->nFilledLen; i++){
02653         putchar(*(char*)(pBuffer->pBuffer + i));
02654       }
02655       pBuffer->nFilledLen = 0;
02656       err = OMX_FillThisBuffer(hComponent, pBuffer);
02657       if(err != OMX_ErrorNone) {
02658         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02659       }
02660     } else if (flagDecodedOutputReceived && (!flagIsDisplayRequested) ) {
02661       if(pBuffer->nFilledLen > 0) {
02662         fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfileAudio);
02663       }
02664       pBuffer->nFilledLen = 0;
02665       err = OMX_FillThisBuffer(hComponent, pBuffer);
02666       if(err != OMX_ErrorNone) {
02667         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02668       }
02669     } else if ((!flagSetupTunnel) && (flagIsDisplayRequested))  { //playback on, redirect to alsa sink, if it is not tunneled
02670       if(!bEOS) {
02671         if(inBufferSinkAudio[0]->pBuffer == pBuffer->pBuffer) {
02672           inBufferSinkAudio[0]->nFilledLen = pBuffer->nFilledLen;
02673           inBufferSinkAudio[0]->nTimeStamp = pBuffer->nTimeStamp;
02674           if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
02675             inBufferSinkAudio[0]->nFlags = pBuffer->nFlags;
02676             pBuffer->nFlags              = 0;
02677           }
02678           err = OMX_EmptyThisBuffer(appPriv->audiosinkhandle, inBufferSinkAudio[0]);
02679         } else {
02680           inBufferSinkAudio[1]->nFilledLen = pBuffer->nFilledLen;
02681           inBufferSinkAudio[1]->nTimeStamp = pBuffer->nTimeStamp;
02682           if(pBuffer->nFlags == OMX_BUFFERFLAG_STARTTIME) {
02683             inBufferSinkAudio[1]->nFlags = pBuffer->nFlags;
02684             pBuffer->nFlags              = 0;
02685           }
02686           err = OMX_EmptyThisBuffer(appPriv->audiosinkhandle, inBufferSinkAudio[1]);
02687         }
02688         if(err != OMX_ErrorNone) {
02689           DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling EmptyThisBuffer\n", __func__,err);
02690         }
02691       } else {
02692         DEBUG(DEFAULT_MESSAGES,"In %s EOS reached\n",__func__);
02693         volCompBufferDropped++;
02694         if(volCompBufferDropped==2) {
02695 //          tsem_up(appPriv->eofSem);
02696         }
02697       }
02698     }
02699   }     else {
02700     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02701   }
02702   return OMX_ErrorNone;
02703 }
02704 
02705 OMX_ERRORTYPE audiosinkEventHandler(
02706   OMX_OUT OMX_HANDLETYPE hComponent,
02707   OMX_OUT OMX_PTR pAppData,
02708   OMX_OUT OMX_EVENTTYPE eEvent,
02709   OMX_OUT OMX_U32 Data1,
02710   OMX_OUT OMX_U32 Data2,
02711   OMX_OUT OMX_PTR pEventData) {
02712   DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
02713   if (Data1 == OMX_CommandStateSet) {
02714     DEBUG(DEB_LEV_SIMPLE_SEQ, "Audio Sink State changed in ");
02715     switch ((int)Data2) {
02716     case OMX_StateInvalid:
02717       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
02718       break;
02719     case OMX_StateLoaded:
02720       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
02721       break;
02722     case OMX_StateIdle:
02723       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
02724       break;
02725     case OMX_StateExecuting:
02726       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
02727       break;
02728     case OMX_StatePause:
02729       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
02730       break;
02731     case OMX_StateWaitForResources:
02732       DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
02733       break;
02734     }
02735     tsem_up(appPriv->audioSinkEventSem);
02736   } else if (Data1 == OMX_CommandPortEnable){
02737     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
02738     tsem_up(appPriv->audioSinkEventSem);
02739   } else if (Data1 == OMX_CommandPortDisable){
02740     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
02741     tsem_up(appPriv->audioSinkEventSem);
02742   } else if (Data1 == OMX_CommandFlush){
02743     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Flush Event\n",__func__);
02744     tsem_up(appPriv->audioSinkEventSem);
02745   } else if(eEvent == OMX_EventBufferFlag) {
02746     DEBUG(DEB_LEV_ERR, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
02747     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
02748       tsem_up(appPriv->eofSem);
02749     }
02750   } else {
02751     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
02752     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
02753   }
02754 
02755   return OMX_ErrorNone;
02756 }
02757 
02758 OMX_ERRORTYPE audiosinkEmptyBufferDone(
02759   OMX_OUT OMX_HANDLETYPE hComponent,
02760   OMX_OUT OMX_PTR pAppData,
02761   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
02762 {
02763   OMX_ERRORTYPE err;
02764   static int alsaSinkBufferDropped=0;
02765   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
02766 
02767   DEBUG(DEB_LEV_PARAMS, "Empty buffer %x\n", (int)pBuffer);
02768   if(!bEOS) {
02769     if(outBufferVolume[0]->pBuffer == pBuffer->pBuffer) {
02770       outBufferVolume[0]->nFilledLen=0;
02771       err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume[0]);
02772     } else {
02773       outBufferVolume[1]->nFilledLen=0;
02774       err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume[1]);
02775     }
02776     if(err != OMX_ErrorNone) {
02777       DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02778     }
02779   } else {
02780     DEBUG(DEFAULT_MESSAGES,"In %s EOS reached\n",__func__);
02781     alsaSinkBufferDropped++;
02782     if(alsaSinkBufferDropped==2) {
02783       tsem_up(appPriv->eofSem);
02784     }
02785   }
02786 
02787   return OMX_ErrorNone;
02788 }
02789 
02790 OMX_ERRORTYPE clocksrcEventHandler(
02791   OMX_OUT OMX_HANDLETYPE hComponent,
02792   OMX_OUT OMX_PTR pAppData,
02793   OMX_OUT OMX_EVENTTYPE eEvent,
02794   OMX_OUT OMX_U32 Data1,
02795   OMX_OUT OMX_U32 Data2,
02796   OMX_OUT OMX_PTR pEventData)
02797 {
02798   DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback\n", __func__);
02799 
02800   if(eEvent == OMX_EventCmdComplete) {
02801     if (Data1 == OMX_CommandStateSet) {
02802       DEBUG(DEB_LEV_SIMPLE_SEQ, "Clock Component State changed in ");
02803       switch ((int)Data2) {
02804       case OMX_StateInvalid:
02805         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
02806         break;
02807       case OMX_StateLoaded:
02808         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
02809         break;
02810       case OMX_StateIdle:
02811         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
02812         break;
02813       case OMX_StateExecuting:
02814         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
02815         break;
02816       case OMX_StatePause:
02817         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
02818         break;
02819       case OMX_StateWaitForResources:
02820         DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
02821         break;
02822       }
02823       tsem_up(appPriv->clockEventSem);
02824     } else if (Data1 == OMX_CommandPortEnable){
02825       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable  Event\n",__func__);
02826       tsem_up(appPriv->clockEventSem);
02827     } else if (Data1 == OMX_CommandPortDisable){
02828       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
02829       tsem_up(appPriv->clockEventSem);
02830     } else {
02831       DEBUG(DEB_LEV_SIMPLE_SEQ,"In %s Received Event Event=%d Data1=%d,Data2=%d\n",__func__,eEvent,(int)Data1,(int)Data2);
02832     }
02833   } else if(eEvent == OMX_EventPortSettingsChanged) {
02834     DEBUG(DEB_LEV_SIMPLE_SEQ,"Clock src  Port Setting Changed event\n");
02835     /*Signal Port Setting Changed*/
02836     tsem_up(appPriv->clockEventSem);
02837   } else if(eEvent == OMX_EventPortFormatDetected) {
02838     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Port Format Detected %x\n", __func__,(int)Data1);
02839   } else if(eEvent == OMX_EventBufferFlag) {
02840     DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
02841     if((int)Data2 == OMX_BUFFERFLAG_EOS) {
02842 //      tsem_up(appPriv->eofSem);
02843     }
02844   } else {
02845     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
02846     DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
02847   }
02848   return OMX_ErrorNone;
02849 }
02850 
02851 OMX_ERRORTYPE clocksrcFillBufferDone(
02852   OMX_OUT OMX_HANDLETYPE hComponent,
02853   OMX_OUT OMX_PTR pAppData,
02854   OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
02855 {
02856   OMX_ERRORTYPE err;
02857   /* Output data to audio decoder */
02858 
02859   if(pBuffer != NULL){
02860     if(!bEOS) {
02861         err = OMX_EmptyThisBuffer(appPriv->clocksrchandle, pBuffer);
02862       if(err != OMX_ErrorNone) {
02863         DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
02864       }
02865       if(pBuffer->nFlags==OMX_BUFFERFLAG_EOS) {
02866         DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Calling Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
02867         bEOS=OMX_TRUE;
02868       }
02869     } else {
02870       DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
02871     }
02872   } else {
02873     DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
02874   }
02875   return OMX_ErrorNone;
02876 }
02877 

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