1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     3 *

     4 * This library is free software; you can redistribute it and/or

     5 * modify it under the terms of the GNU Lesser General Public

     6 * License as published by the Free Software Foundation; either

     7 * version 2 of the License, or (at your option) any later version.

     8 *

     9 * This library is distributed in the hope that it will be useful,

    10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12 * Lesser General Public License for more details.

    13 *

    14 * You should have received a copy of the GNU Lesser General Public

    15 * License along with this library; if not, write to the

    16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    17 * Boston, MA 02111-1307, USA.

    18 *

    19 * Description:

    20 *

    21 */

    22 

    23 #include "gstreamer.h"

    24 #include "GlibEventHandler.h"

    25 #include <avkon.hrh>

    26 #include <aknnotewrappers.h>

    27 #include <stringloader.h>

    28 #include <GSTPlayer.rsg>

    29 #include <CAknMemorySelectionDialog.h>

    30 #include <e32base.h>

    31 #include <stdlib.h>

    32 #include <mmf/server/sounddevice.h>

    33 

    34 #include "gstplayerappview.h"

    35 

    36 GstElement *pipeline, *source, *wavparse,*sink,*decoder,*conv,*resample,*record,*fakesink,*filesink,*encoder,*filter,*wavenc;

    37 GstBus *bus;

    38 GstCaps* caps;

    39 GstState current,pending;

    40 char carray[1024];

    41 

    42 CGSTPlayerAppView *iGstView;

    43 

    44 GstPad *dssinkpad;

    45 GstCaps *dssinkcap;

    46 GstPad *dssrcpad;

    47 GstCaps *dssrccap;

    48 GstStructure *str;

    49 

    50 gboolean negcaps = FALSE;

    51 

    52 static gboolean print_field (GQuark field, const GValue *value, gpointer pfx);

    53 static void print_caps (const GstCaps *caps, const gchar *pfx);

    54 

    55 

    56 

    57 static void

    58 cb_raw_playback_handoff (GstElement *src, GstBuffer *buffer, GstPad *pad,

    59         gpointer user_data)

    60     {

    61     static gint readbytes = 0;

    62     static gboolean eofReached = FALSE;

    63 

    64     size_t readsize;

    65     gint size;

    66     FILE *f;

    67     GstCaps *bufCaps;

    68     if ( eofReached == TRUE )

    69         {

    70         //gst_element_set_state (pipeline, GST_STATE_NULL);

    71        // gst_object_unref (GST_OBJECT (pipeline));

    72         if ( gst_element_send_event (src, gst_event_new_eos ()) == TRUE )

    73             {

    74             g_print ("posted eos");

    75            }

    76      

    77        else

    78            {

    79             //g_print ("unable to post eos");

    80           }

    81        return;

    82        }

    83 

    84     readsize = 0;

    85     f = fopen (carray, "r");

    86     eofReached = TRUE;

    87     if ( fseek(f, readbytes, 0) == 0 )

    88         {

    89         readsize = fread (GST_BUFFER_DATA (buffer),1,GST_BUFFER_SIZE (buffer),f);

    90         eofReached = FALSE;

    91         GST_BUFFER_SIZE (buffer) = readsize;

    92         }

    93     fclose(f);

    94 

    95     size = GST_BUFFER_SIZE (buffer);

    96     readbytes += readsize;

    97     if ( (readsize < size) || (readsize == 0) )

    98         {

    99         eofReached = TRUE;

   100         }

   101     

   102     bufCaps = gst_caps_new_simple ("audio/x-raw-int",

   103               "width", G_TYPE_INT, 16,

   104               "depth", G_TYPE_INT, 16,

   105               "signed",G_TYPE_BOOLEAN, TRUE,

   106               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   107               "rate", G_TYPE_INT, 8000,

   108               "channels", G_TYPE_INT, 1, NULL);

   109     

   110     gst_buffer_set_caps(buffer,bufCaps);

   111 

   112     }

   113 

   114 static void

   115 cb_play_mp3_handoff (GstElement *fakesrc,

   116         GstBuffer  *buffer,

   117         GstPad     *pad,

   118         gpointer    user_data)

   119 {

   120 GstCaps *bufCaps;

   121   static gint readbytes = 0;

   122   size_t readsize = 0;

   123   int size = GST_BUFFER_SIZE (buffer);

   124   

   125   FILE *f = fopen (carray, "r");

   126   fseek(f,readbytes,0);

   127   readsize = fread(GST_BUFFER_DATA (buffer),1,GST_BUFFER_SIZE (buffer),f);

   128   readbytes += readsize;

   129   GST_BUFFER_SIZE (buffer) = readsize;

   130   if(readsize == 0)

   131       {

   132       gst_element_send_event(fakesrc,gst_event_new_eos());

   133       }

   134   fclose(f);

   135  

   136 }

   137 static void

   138 cb_record_raw_handoff (GstElement *fakesrc,

   139         GstBuffer  *buffer,

   140         GstPad     *pad,

   141         gpointer    user_data)

   142 {

   143   int size = GST_BUFFER_SIZE (buffer);

   144   //g_print ("[%u]", size);

   145   FILE *f = fopen (carray, "a");

   146   fwrite(GST_BUFFER_DATA (buffer),1,GST_BUFFER_SIZE (buffer),f);

   147   fclose(f);

   148 }

   149 

   150 

   151 static gboolean

   152 bus_call (GstBus     *bus,

   153           GstMessage *msg,

   154           gpointer    data)

   155 {

   156   switch (GST_MESSAGE_TYPE (msg)) {

   157     case GST_MESSAGE_EOS:

   158         gst_element_set_state (pipeline, GST_STATE_NULL);

   159         gst_object_unref (GST_OBJECT (pipeline));

   160       break;

   161     case GST_MESSAGE_ERROR: {

   162       gchar *debug;

   163       GError *err;

   164       gst_message_parse_error (msg, &err, &debug);

   165       g_free (debug);

   166       g_print ("Error: %s\n", err->message);

   167       g_error_free (err);

   168       break;

   169     }

   170     default:

   171       break;

   172   }

   173 

   174   return TRUE;

   175 }

   176 

   177 

   178 static void 

   179 new_pad_cb (GstElement *wavparse, GstPad *new_pad, gpointer pipeline)

   180  {

   181    //GstElement *sink,*conv,*resample;

   182    gst_element_set_state ((_GstElement *)pipeline, GST_STATE_PAUSED);

   183    sink = gst_element_factory_make ("devsoundsink", "sink");

   184    conv = gst_element_factory_make ("audioconvert", "audioconvert");

   185   	if (!conv) {

   186     	g_print ("could not create \"audioconvert\" element!");

   187     	return;

   188   		}

   189    resample = gst_element_factory_make ("audioresample", "audioresample");

   190   	if (!resample) {

   191     	g_print ("could not create \"audioresample\" element!");

   192     	return ;

   193   		}

   194    gst_bin_add_many(GST_BIN (pipeline), conv, resample, sink, NULL);

   195    

   196   // if (!gst_element_link (wavparse, sink))

   197      // g_error ("link(wavparse, sink) failed!\n");

   198      

   199  	if(! gst_element_link_many (wavparse,conv, resample, sink, NULL))

   200   		g_print ("link(wavparse,conv,remaple sink) failed!\n");  

   201  

   202    	gst_element_set_state ((_GstElement *)pipeline, GST_STATE_PLAYING);

   203  }

   204 

   205  #define FILENAME 1024

   206  int GstreamerNew(TFileName filename)

   207  {

   208   size_t ret;

   209   

   210   ret = wcstombs(carray, (const wchar_t *)filename.PtrZ(), FILENAME);

   211   int file_type=0;

   212   

   213   

   214   

   215   	char *p;

   216 	p = strrchr(carray, '.');

   217 

   218 	if ((p != NULL) && (strcmp(p, ".mp3") == 0))

   219 	{

   220 	file_type=2;	

   221 	}

   222 	else if ((p != NULL) && (strcmp(p, ".wav") == 0))

   223 	{

   224 	file_type=1;	

   225 	}

   226     else if ((p != NULL) && (strcmp(p, ".raw") == 0))

   227     {

   228     file_type=3;    

   229     }

   230     else if ((p != NULL) && (strcmp(p, ".amr") == 0))

   231     {

   232     file_type=4;    

   233     }

   234     else if ((p != NULL) && (strcmp(p, ".g711") == 0))

   235     {

   236     file_type=5;    

   237     }

   238     else if ((p != NULL) && (strcmp(p, ".g729") == 0))

   239     {

   240     file_type=6;    

   241     }

   242     else if ((p != NULL) && (strcmp(p, ".lbc") == 0))

   243     {

   244     file_type=7;    

   245     }

   246 	else

   247 		return -1;

   248 	

   249 	if(file_type==1)

   250 	{

   251 		gst_play_wave();

   252 	}

   253 	else if(file_type==2)

   254 	{

   255 		gst_play_mp3();

   256 	}

   257     else if(file_type==3)

   258     {

   259         gst_play_raw();

   260     }

   261     else if(file_type==4)

   262     {

   263         gst_play_amr();

   264     }

   265     else if(file_type==5)

   266     {

   267         gst_play_g711();

   268     }

   269     else if(file_type==6)

   270     {

   271         gst_play_g729();

   272     }

   273     else if(file_type==7)

   274     {

   275         gst_play_ilbc();

   276     }

   277 

   278 	else

   279 	{

   280 		return 0;

   281 	}

   282  } 

   283  

   284  

   285 int gst_play_mp3()

   286 {

   287  /* create elements */

   288  gboolean link_ok;

   289  

   290  pipeline = gst_pipeline_new ("pipeline");

   291  source = gst_element_factory_make ("filesrc", "filesrc");

   292  //sink = gst_element_factory_make ("fakesink", "sink");

   293  sink = gst_element_factory_make ("devsoundsink", "sink");

   294 

   295  caps = gst_caps_new_simple ("audio/mp3",

   296               "width", G_TYPE_INT, 16,

   297               "depth", G_TYPE_INT, 16,

   298               "signed",G_TYPE_BOOLEAN, TRUE,

   299               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   300               "rate", G_TYPE_INT, 16000,

   301               "channels", G_TYPE_INT, 2, NULL);

   302              

   303  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   304  gst_bus_add_watch( bus, bus_call, NULL);

   305  gst_object_unref (bus);

   306 

   307  g_object_set (G_OBJECT (source), "location", carray, NULL);

   308 

   309  gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);

   310  

   311  //gst_element_link (source, sink);

   312  link_ok = gst_element_link_filtered (source, sink, caps);

   313 

   314  gst_element_set_state (pipeline, GST_STATE_PLAYING);

   315 

   316  return 0;  

   317 }

   318  

   319 

   320  int gst_play_wave()

   321  {

   322     /* create elements */

   323      if(!pipeline)

   324          {

   325          pipeline = gst_pipeline_new ("pipeline");

   326          bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   327          gst_bus_add_watch (bus, bus_call, NULL);

   328          gst_object_unref (bus);

   329          }

   330 

   331      if(!source)

   332          {

   333          source = gst_element_factory_make ("filesrc", "pavsrc");

   334          g_object_set (G_OBJECT (source), "location", carray, NULL);

   335          gst_bin_add (GST_BIN (pipeline), source);

   336          }

   337 

   338      if(!wavparse)

   339          {

   340          wavparse = gst_element_factory_make ("wavparse", "parse");

   341          gst_bin_add (GST_BIN (pipeline), wavparse );

   342          g_signal_connect (wavparse, "pad-added", G_CALLBACK (new_pad_cb),pipeline);

   343          }

   344  

   345       /* set filename property on the file source */

   346       if (!gst_element_link (source, wavparse))

   347           {

   348           g_print("could not link elements!");

   349           return -1;

   350           }

   351           

   352 

   353       gst_element_set_state (pipeline, GST_STATE_PLAYING); 

   354       return 0; 

   355  }

   356  

   357  int gst_record_wav()

   358     {

   359 

   360     /* create a new bin to hold the elements */

   361     pipeline = gst_pipeline_new("pipeline");

   362 

   363     record = gst_element_factory_make("devsoundsrc", "record_audio");

   364     if (!record)

   365         {

   366         g_print("could not create \"record\" element!");

   367         return -1;

   368         }

   369     

   370     filesink = gst_element_factory_make("filesink", "filesink");

   371     if (!filesink)

   372         {

   373         g_print("could not create \"filesink\" element!");

   374         return -1;

   375         }

   376 

   377     wavenc = gst_element_factory_make("wavenc", "wavencoder");

   378     if (!wavenc)

   379         {

   380         g_print("could not create \"wavenc\" element!");

   381         return -1;

   382         }

   383 

   384     _LIT(KFILENAME,"c:\\data\\test.wav");

   385     TFileName fn;

   386     fn.Append(KFILENAME);

   387     TInt ret;

   388     // char carray[FILENAME];

   389     ret = wcstombs(carray, (const wchar_t *)fn.PtrZ(), FILENAME);

   390 

   391     g_object_set(G_OBJECT (filesink), "location", carray, NULL);

   392     bus = gst_pipeline_get_bus(GST_PIPELINE (pipeline));

   393     gst_bus_add_watch(bus, bus_call, NULL);

   394     gst_object_unref(bus);

   395 

   396     /* add objects to the main pipeline */

   397     gst_bin_add_many(GST_BIN (pipeline),record,wavenc,filesink, NULL);

   398 

   399     /* link the elements */

   400     //gst_element_link_many(record, wavenc,filesink, NULL);

   401     caps = gst_caps_new_simple ("audio/x-raw-int",

   402               "width", G_TYPE_INT, 16,

   403               "depth", G_TYPE_INT, 16,

   404               "signed",G_TYPE_BOOLEAN, TRUE,

   405               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   406               "rate", G_TYPE_INT, 16000,

   407               "channels", G_TYPE_INT, 1, NULL);

   408     

   409     gst_element_link_filtered (record, wavenc, caps);

   410     gst_element_link (wavenc, filesink);

   411     gst_caps_unref (caps);

   412 

   413     /* start recording */

   414     gst_element_set_state(pipeline, GST_STATE_PLAYING);

   415 

   416     return 0;

   417     }

   418  

   419  int gst_record_amr()

   420  {

   421  iGstView->DrawText(_L("Recording AMR"),KRgbRed);

   422 

   423    /* create a new bin to hold the elements */

   424   pipeline = gst_pipeline_new ("pipeline");

   425   

   426   //g_print ("pipeline created");

   427   record = gst_element_factory_make ("devsoundsrc", "record_audio"); 

   428  // encoder = gst_element_factory_make ("wavenc", NULL); 

   429   if (!record) {

   430     g_print ("could not create \"record\" element!");

   431     iGstView->DrawText(_L("Devsound src not available"),KRgbRed);

   432     return -1;

   433   }

   434 

   435   filesink = gst_element_factory_make("filesink", "filesink");

   436       if (!filesink)

   437           {

   438           g_print("could not create \"filesink\" element!");

   439           return -1;

   440           }

   441 

   442   caps = gst_caps_new_simple ("audio/amr",

   443              "width", G_TYPE_INT, 8,

   444              "depth", G_TYPE_INT, 8,

   445              "signed",G_TYPE_BOOLEAN, TRUE,

   446              "endianness",G_TYPE_INT, G_BYTE_ORDER,

   447              "rate", G_TYPE_INT,  8000,

   448              "channels", G_TYPE_INT, 1, NULL);

   449   

   450   

   451   g_object_set (G_OBJECT (record),

   452             "blocksize", 1280,

   453              NULL);

   454   

   455   _LIT(KFILENAME,"c:\\data\\recordtest.amr");

   456   TFileName fn;

   457   fn.Append(KFILENAME);

   458   TInt ret;

   459   ret = wcstombs(carray, (const wchar_t *)fn.PtrZ(), FILENAME);

   460   g_object_set(G_OBJECT (filesink), "location", carray, NULL);

   461    

   462   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   463   gst_bus_add_watch (bus, bus_call, NULL);

   464   gst_object_unref (bus);

   465   

   466 

   467   /* add objects to the main pipeline */

   468   gst_bin_add_many(GST_BIN (pipeline),record,filesink , NULL);

   469   /* link the elements */

   470   gst_element_link_filtered (record, filesink, caps);

   471   gst_element_set_state (pipeline, GST_STATE_PLAYING);

   472   

   473   return 0;

   474  }

   475  

   476  int gst_record_g711()

   477   {

   478     /* create a new bin to hold the elements */

   479    pipeline = gst_pipeline_new ("pipeline");

   480    

   481    //g_print ("pipeline created");

   482    record = gst_element_factory_make ("devsoundsrc", "record_audio"); 

   483   // encoder = gst_element_factory_make ("wavenc", NULL); 

   484    if (!record) {

   485      g_print ("could not create \"record\" element!");

   486      return -1;

   487    }

   488 

   489    filesink = gst_element_factory_make("filesink", "filesink");

   490        if (!filesink)

   491            {

   492            g_print("could not create \"filesink\" element!");

   493            return -1;

   494            }

   495 

   496    caps = gst_caps_new_simple ("audio/x-alaw",

   497               "width", G_TYPE_INT, 8,

   498               "depth", G_TYPE_INT, 8,

   499               "signed",G_TYPE_BOOLEAN, TRUE,

   500               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   501               "rate", G_TYPE_INT,  8000,

   502               "channels", G_TYPE_INT, 1, NULL);

   503    

   504    g_object_set (G_OBJECT (record),

   505              "blocksize", 1280,

   506               NULL);

   507    

   508    _LIT(KFILENAME,"c:\\data\\recordtest.g711");

   509    TFileName fn;

   510    fn.Append(KFILENAME);

   511    TInt ret;

   512    ret = wcstombs(carray, (const wchar_t *)fn.PtrZ(), FILENAME);

   513    g_object_set(G_OBJECT (filesink), "location", carray, NULL);

   514     

   515    bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   516    gst_bus_add_watch (bus, bus_call, NULL);

   517    gst_object_unref (bus);

   518    

   519 

   520    /* add objects to the main pipeline */

   521    gst_bin_add_many(GST_BIN (pipeline),record,filesink , NULL);

   522    /* link the elements */

   523    gst_element_link_filtered (record, filesink, caps);

   524    gst_element_set_state (pipeline, GST_STATE_PLAYING);

   525    

   526    return 0;

   527   }

   528  

   529  int gst_record_g729()

   530   {

   531     /* create a new bin to hold the elements */

   532    pipeline = gst_pipeline_new ("pipeline");

   533    

   534    record = gst_element_factory_make ("devsoundsrc", "record_audio"); 

   535    if (!record) {

   536      g_print ("could not create \"record\" element!");

   537      return -1;

   538    }

   539  

   540    filesink = gst_element_factory_make("filesink", "filesink");

   541        if (!filesink)

   542            {

   543            g_print("could not create \"filesink\" element!");

   544            return -1;

   545            }

   546 

   547    caps = gst_caps_new_simple ("audio/g729",

   548               "width", G_TYPE_INT, 16,

   549               "depth", G_TYPE_INT, 16,

   550               "signed",G_TYPE_BOOLEAN, TRUE,

   551               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   552               "rate", G_TYPE_INT,  8000,

   553               "channels", G_TYPE_INT, 1, NULL);

   554    

   555    g_object_set (G_OBJECT (record),

   556              "blocksize", 1280,

   557               NULL);

   558    

   559    _LIT(KFILENAME,"c:\\data\\recordtest.g729");

   560    TFileName fn;

   561    fn.Append(KFILENAME);

   562    TInt ret;

   563    ret = wcstombs(carray, (const wchar_t *)fn.PtrZ(), FILENAME);

   564    g_object_set(G_OBJECT (filesink), "location", carray, NULL);

   565     

   566    bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   567    gst_bus_add_watch (bus, bus_call, NULL);

   568    gst_object_unref (bus);

   569    

   570 

   571    /* add objects to the main pipeline */

   572    gst_bin_add_many(GST_BIN (pipeline),record,filesink , NULL);

   573    /* link the elements */

   574    gst_element_link_filtered (record, filesink, caps);

   575    gst_element_set_state (pipeline, GST_STATE_PLAYING);

   576    

   577    return 0;

   578   }

   579  

   580  int gst_record_ilbc()

   581   {

   582     /* create a new bin to hold the elements */

   583    pipeline = gst_pipeline_new ("pipeline");

   584    

   585    record = gst_element_factory_make ("devsoundsrc", "record_audio"); 

   586    if (!record) {

   587      g_print ("could not create \"record\" element!");

   588      return -1;

   589    }

   590 

   591    filesink = gst_element_factory_make("filesink", "filesink");

   592        if (!filesink)

   593            {

   594            g_print("could not create \"filesink\" element!");

   595            return -1;

   596            }

   597 

   598    caps = gst_caps_new_simple ("audio/ilbc",

   599               "width", G_TYPE_INT, 16,

   600               "depth", G_TYPE_INT, 16,

   601               "signed",G_TYPE_BOOLEAN, TRUE,

   602               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   603               "rate", G_TYPE_INT,  8000,

   604               "channels", G_TYPE_INT, 1, NULL);

   605    

   606    g_object_set (G_OBJECT (record),

   607              "blocksize", 1280,

   608               NULL);

   609    

   610    _LIT(KFILENAME,"c:\\data\\recordtest.lbc");

   611    TFileName fn;

   612    fn.Append(KFILENAME);

   613    TInt ret;

   614    ret = wcstombs(carray, (const wchar_t *)fn.PtrZ(), FILENAME);

   615    g_object_set(G_OBJECT (filesink), "location", carray, NULL);

   616     

   617    bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   618    gst_bus_add_watch (bus, bus_call, NULL);

   619    gst_object_unref (bus);

   620    

   621 

   622    /* add objects to the main pipeline */

   623    gst_bin_add_many(GST_BIN (pipeline),record,filesink , NULL);

   624    /* link the elements */

   625    gst_element_link_filtered (record, filesink, caps);

   626    gst_element_set_state (pipeline, GST_STATE_PLAYING);

   627    

   628    return 0;

   629   }

   630 

   631  int gst_record_raw()

   632  {

   633  

   634    /* create a new bin to hold the elements */

   635   pipeline = gst_pipeline_new ("pipeline");

   636   

   637   //g_print ("pipeline created");

   638   record = gst_element_factory_make ("devsoundsrc", "record_audio"); 

   639  // encoder = gst_element_factory_make ("wavenc", NULL); 

   640   if (!record) {

   641     g_print ("could not create \"record\" element!");

   642     return -1;

   643   }

   644   //g_print ("record created");

   645 

   646   filesink = gst_element_factory_make("filesink", "filesink");

   647       if (!filesink)

   648           {

   649           g_print("could not create \"filesink\" element!");

   650           return -1;

   651           }

   652   //GstRingBufferSpec

   653   //g_print ("sink created");

   654   caps = gst_caps_new_simple ("audio/x-raw-int",

   655              "width", G_TYPE_INT, 16,

   656              "depth", G_TYPE_INT, 16,

   657              "signed",G_TYPE_BOOLEAN, TRUE,

   658              "endianness",G_TYPE_INT, G_BYTE_ORDER,

   659              "rate", G_TYPE_INT,  8000,

   660              "channels", G_TYPE_INT, 1, NULL);

   661   

   662   //g_print ("caps created");

   663    g_object_set (G_OBJECT (record),

   664              //"signal-handoffs", TRUE,

   665              "blocksize", 1280,

   666           // "gain",10000,

   667               NULL);

   668   

   669   /*g_object_set (G_OBJECT (fakesink),

   670              "signal-handoffs", TRUE,

   671              "sizemax", 4096,

   672              "sizetype", 2, NULL);*/

   673   

   674   _LIT(KFILENAME,"c:\\data\\test.raw");

   675   TFileName fn;

   676   fn.Append(KFILENAME);

   677   TInt ret;

   678   //char carray[FILENAME];

   679   carray[0]='\0';

   680   ret = wcstombs(carray, (const wchar_t *)fn.PtrZ(), FILENAME);

   681    

   682    

   683   g_object_set (G_OBJECT (filesink), "location", carray,"buffer-size",1280, NULL);

   684   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   685   gst_bus_add_watch (bus, bus_call, NULL);

   686   gst_object_unref (bus);

   687   

   688 

   689   /* add objects to the main pipeline */

   690   gst_bin_add_many(GST_BIN (pipeline),record,filesink , NULL);

   691   //g_print ("added to pipe");

   692   /* link the elements */

   693   //gst_element_link(record,/*encoder,*/ fakesink/*audiosink*/);

   694   gst_element_link_filtered (record, filesink, caps);

   695   //g_signal_connect (fakesink, "handoff", G_CALLBACK (cb_record_raw_handoff), NULL);

   696   /* start recording */

   697  // g_print ("start pipe");

   698  

   699   gst_element_set_state (pipeline, GST_STATE_PLAYING);

   700   

   701   return 0;

   702  }

   703      

   704  

   705  int gst_play_raw()

   706  {

   707  /* create elements */

   708  gboolean link_ok;

   709  

   710  pipeline = gst_pipeline_new ("pipeline");

   711  source = gst_element_factory_make ("filesrc", "filesrc");

   712  //sink = gst_element_factory_make ("fakesink", "sink");

   713  sink = gst_element_factory_make ("devsoundsink", "sink");

   714 

   715 caps = gst_caps_new_simple ("audio/x-raw-int",

   716              "width", G_TYPE_INT, 16,

   717              "depth", G_TYPE_INT, 16,

   718              "signed",G_TYPE_BOOLEAN, TRUE,

   719              "endianness",G_TYPE_INT, G_BYTE_ORDER,

   720              "rate", G_TYPE_INT,  8000,

   721              "channels", G_TYPE_INT, 1, NULL);

   722              

   723  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   724  gst_bus_add_watch( bus, bus_call, NULL);

   725  gst_object_unref (bus);

   726 

   727  /*g_object_set (G_OBJECT(source),

   728          "signal-handoffs", TRUE,

   729          //"num-buffers", 4,

   730          "sizemax", 4096,

   731          "sizetype", 2,

   732          NULL);*/

   733  

   734  g_object_set (G_OBJECT (source), "location", carray, NULL);

   735 // g_signal_connect (source, "handoff", G_CALLBACK (cb_raw_playback_handoff), NULL);

   736 

   737  gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);

   738  

   739  //gst_element_link (source, sink);

   740  link_ok = gst_element_link_filtered (source, sink, caps);

   741 

   742  gst_element_set_state (pipeline, GST_STATE_PLAYING);

   743 

   744 while (caps->refcount > 1)

   745      {

   746      gst_caps_unref (caps);

   747      }

   748  gst_caps_unref (caps);

   749 

   750  

   751  return 0; 

   752  }

   753 

   754  int gst_play_amr()

   755   {

   756   /* create elements */

   757   gboolean link_ok;

   758   

   759   pipeline = gst_pipeline_new ("pipeline");

   760   source = gst_element_factory_make ("filesrc", "filesrc");

   761   //sink = gst_element_factory_make ("fakesink", "sink");

   762   sink = gst_element_factory_make ("devsoundsink", "sink");

   763 

   764  caps = gst_caps_new_simple ("audio/amr",

   765               "width", G_TYPE_INT, 8,

   766               "depth", G_TYPE_INT, 8,

   767               "signed",G_TYPE_BOOLEAN, TRUE,

   768               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   769               "rate", G_TYPE_INT,  8000,

   770               "channels", G_TYPE_INT, 1, NULL);

   771               

   772   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   773   gst_bus_add_watch( bus, bus_call, NULL);

   774   gst_object_unref (bus);

   775 

   776   g_object_set (G_OBJECT (source), "location", carray, NULL);

   777 

   778   gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);

   779   

   780   link_ok = gst_element_link_filtered (source, sink, caps);

   781 

   782   gst_element_set_state (pipeline, GST_STATE_PLAYING);

   783 

   784   return 0; 

   785   }

   786 

   787  int gst_play_g711()

   788   {

   789   /* create elements */

   790   gboolean link_ok;

   791   

   792   pipeline = gst_pipeline_new ("pipeline");

   793   source = gst_element_factory_make ("filesrc", "filesrc");

   794   sink = gst_element_factory_make ("devsoundsink", "sink");

   795 

   796  caps = gst_caps_new_simple ("audio/x-alaw",

   797               "width", G_TYPE_INT, 16,

   798               "depth", G_TYPE_INT, 16,

   799               "signed",G_TYPE_BOOLEAN, TRUE,

   800               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   801               "rate", G_TYPE_INT,  8000,

   802               "channels", G_TYPE_INT, 1, NULL);

   803               

   804   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   805   gst_bus_add_watch( bus, bus_call, NULL);

   806   gst_object_unref (bus);

   807 

   808   g_object_set (G_OBJECT (source), "location", carray, NULL);

   809   gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);

   810   

   811   link_ok = gst_element_link_filtered (source, sink, caps);

   812 

   813   gst_element_set_state (pipeline, GST_STATE_PLAYING);

   814 

   815   return 0; 

   816   }

   817  int gst_play_g729()

   818   {

   819   /* create elements */

   820   gboolean link_ok;

   821   

   822   pipeline = gst_pipeline_new ("pipeline");

   823   source = gst_element_factory_make ("filesrc", "filesrc");

   824   sink = gst_element_factory_make ("devsoundsink", "sink");

   825 

   826  caps = gst_caps_new_simple ("audio/g729",

   827               "width", G_TYPE_INT, 16,

   828               "depth", G_TYPE_INT, 16,

   829               "signed",G_TYPE_BOOLEAN, TRUE,

   830               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   831               "rate", G_TYPE_INT,  8000,

   832               "channels", G_TYPE_INT, 1, NULL);

   833               

   834   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   835   gst_bus_add_watch( bus, bus_call, NULL);

   836   gst_object_unref (bus);

   837 

   838   g_object_set (G_OBJECT (source), "location", carray, NULL);

   839 

   840   gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);

   841   

   842   link_ok = gst_element_link_filtered (source, sink, caps);

   843 

   844   gst_element_set_state (pipeline, GST_STATE_PLAYING);

   845 

   846   return 0; 

   847   }

   848  int gst_play_ilbc()

   849   {

   850   /* create elements */

   851   gboolean link_ok;

   852   

   853   pipeline = gst_pipeline_new ("pipeline");

   854   source = gst_element_factory_make ("filesrc", "filesrc");

   855   sink = gst_element_factory_make ("devsoundsink", "sink");

   856 

   857  caps = gst_caps_new_simple ("audio/ilbc",

   858               "width", G_TYPE_INT, 16,

   859               "depth", G_TYPE_INT, 16,

   860               "signed",G_TYPE_BOOLEAN, TRUE,

   861               "endianness",G_TYPE_INT, G_BYTE_ORDER,

   862               "rate", G_TYPE_INT,  8000,

   863               "channels", G_TYPE_INT, 1, NULL);

   864               

   865   bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));

   866   gst_bus_add_watch( bus, bus_call, NULL);

   867   gst_object_unref (bus);

   868 

   869   g_object_set (G_OBJECT (source), "location", carray, NULL);

   870 

   871   gst_bin_add_many (GST_BIN (pipeline), source, sink, NULL);

   872   

   873   link_ok = gst_element_link_filtered (source, sink, caps);

   874 

   875   gst_element_set_state (pipeline, GST_STATE_PLAYING);

   876   return 0; 

   877   }

   878 

   879  

   880  //******

   881  int gst_current_volume()

   882      {     

   883      if(!sink)

   884          {

   885          iGstView->DrawText(_L("Devsound sink not available"),KRgbRed);

   886          return -1;

   887          }

   888      int vol;

   889      TBuf<25> currentvolume(_L("current volume "));    

   890      g_object_get(G_OBJECT(sink),

   891                     "volume",&vol,NULL);

   892      

   893      currentvolume.AppendNum(vol);

   894      

   895      iGstView->DrawText(currentvolume,KRgbBlack);

   896      return 0;

   897      }

   898  

   899  int gst_max_volume()

   900       {    

   901       if(!sink)

   902            {

   903            iGstView->DrawText(_L("Devsound sink not available"),KRgbRed);

   904            return -1;

   905            }

   906       

   907       int maxvol;

   908       TBuf<25> maxvolume(_L("max volume "));   

   909       

   910       g_object_get(G_OBJECT(sink),

   911                      "maxvolume",&maxvol,NULL);

   912       

   913       maxvolume.AppendNum(maxvol);

   914       

   915       iGstView->DrawText(maxvolume,KRgbBlack);

   916       return 0;

   917       

   918       }

   919  int gst_volume_up()

   920      {

   921      

   922      if(!sink)

   923           {

   924           iGstView->DrawText(_L("Devsound sink not available"),KRgbRed);

   925           return -1;

   926           }

   927      iGstView->DrawText(_L("volume up"),KRgbBlack);

   928      int maxvol;

   929      g_object_get(G_OBJECT(sink),

   930                        "maxvolume",&maxvol,NULL);

   931      g_object_set (G_OBJECT (sink), 

   932                         "volume", maxvol, NULL);

   933      return 0;

   934      }

   935 

   936  int gst_volume_down()

   937      {

   938      if(!sink)

   939           {

   940           iGstView->DrawText(_L("Devsound sink not available"),KRgbRed);

   941           return -1;

   942           }

   943      

   944      iGstView->DrawText(_L("volume down"),KRgbBlack);

   945      int maxvol;

   946      g_object_get(G_OBJECT(sink),

   947                         "maxvolume",&maxvol,NULL);

   948      g_object_set (G_OBJECT (sink), 

   949                         "volume", maxvol/2, NULL);

   950      return 0;

   951      }

   952  

   953  int gst_current_gain()

   954      {     

   955      if(!record)

   956          {

   957          iGstView->DrawText(_L("Devsound source not available"),KRgbRed);

   958          return -1;

   959          }

   960      int gain;

   961      TBuf<25> currentgain(_L("current gain "));    

   962      g_object_get(G_OBJECT(record),

   963                     "gain",&gain,NULL);

   964      

   965      currentgain.AppendNum(gain);

   966      

   967      iGstView->DrawText(currentgain,KRgbBlack);

   968      return 0;

   969      }

   970  

   971  int gst_max_gain()

   972       {    

   973       if(!record)

   974            {

   975            iGstView->DrawText(_L("Devsound source not available"),KRgbRed);

   976            return -1;

   977            }

   978       

   979       int max;

   980       TBuf<25> maxgain(_L("max gain "));   

   981       

   982       g_object_get(G_OBJECT(record),

   983                      "maxgain",&max,NULL);

   984       

   985       maxgain.AppendNum(max);

   986       

   987       iGstView->DrawText(maxgain,KRgbBlack);

   988       return 0;

   989       

   990       }

   991  int gst_gain_up()

   992      {

   993      

   994      if(!record)

   995           {

   996           iGstView->DrawText(_L("Devsound source not available"),KRgbRed);

   997           return -1;

   998           }

   999      int max;

  1000      g_object_get(G_OBJECT(record),

  1001                       "maxgain",&max,NULL);

  1002      

  1003      iGstView->DrawText(_L("gain up"),KRgbBlack);

  1004      g_object_set (G_OBJECT (record), 

  1005                         "gain", max, NULL);

  1006      return 0;

  1007      }

  1008 

  1009  int gst_gain_down()

  1010      {

  1011      if(!record)

  1012           {

  1013           iGstView->DrawText(_L("Devsound source not available"),KRgbRed);

  1014           return -1;

  1015           }

  1016      int max;

  1017      g_object_get(G_OBJECT(record),

  1018                       "maxgain",&max,NULL);

  1019      iGstView->DrawText(_L("gain down"),KRgbBlack);

  1020      g_object_set (G_OBJECT (sink), 

  1021                         "gain", max/2, NULL);

  1022      return 0;

  1023      }

  1024  

  1025  

  1026  

  1027  int gst_balance()

  1028      {

  1029      if(!sink)

  1030            {

  1031            iGstView->DrawText(_L("Devsound sink not available"),KRgbRed);

  1032            return -1;

  1033            }

  1034       

  1035       iGstView->DrawText(_L("balance"),KRgbBlack);

  1036     /*  g_object_set (G_OBJECT (sink), 

  1037                          "left balance", 5000,

  1038                          "right balance",5000,NULL);

  1039                          */

  1040      return 0;

  1041      }

  1042  

  1043  void samplesplayed()

  1044       {

  1045       if(!sink)

  1046            {

  1047            iGstView->DrawText(_L("Devsound sink not available"),KRgbRed);      

  1048            }

  1049       int samples;

  1050       TBuf<25> samplesplayed(_L("samples played "));    

  1051       g_object_get (G_OBJECT (sink), 

  1052                    "samples played", &samples, NULL);

  1053       

  1054       samplesplayed.AppendNum(samples);

  1055       iGstView->DrawText(samplesplayed,KRgbBlack);   

  1056       }

  1057 

  1058  void samplesrecorded()

  1059        {

  1060        if(!record)

  1061             {

  1062             iGstView->DrawText(_L("Devsound src not available"),KRgbRed);      

  1063             }

  1064        int samples;

  1065        TBuf<25> samplesrecorded(_L("samples recorded "));    

  1066        g_object_get (G_OBJECT (record), 

  1067                     "samples recorded", &samples, NULL);

  1068        

  1069        samplesrecorded.AppendNum(samples);

  1070        iGstView->DrawText(samplesrecorded,KRgbBlack);   

  1071        } 

  1072  

  1073  static gboolean print_field (GQuark field, const GValue *value, gpointer pfx)

  1074      {

  1075      gchar *str = gst_value_serialize (value);

  1076      

  1077      const gchar* c;

  1078 

  1079      RDebug::Printf("%s  %15s: %s\n", (gchar *) pfx, c = g_quark_to_string (field), str);

  1080      

  1081      if(negcaps)

  1082          {

  1083          TPtrC8 property((const TText8*)c);

  1084          TPtrC8 val((const TText8*)str);

  1085          TBuf<10> appdval;

  1086          appdval.Copy(val);

  1087       

  1088          TBuf<25> name;

  1089          name.Copy(property);

  1090          name.Append(':');

  1091          name.Append(appdval);

  1092        

  1093          iGstView->DrawText(name,KRgbBlack);

  1094          }    

  1095      g_free (str);

  1096      return TRUE;

  1097      }

  1098 

  1099  static void print_caps (const GstCaps *caps, const gchar *pfx)

  1100      {

  1101      guint i;

  1102 

  1103      g_return_if_fail (caps != NULL);

  1104 

  1105      if (gst_caps_is_any (caps)) {

  1106      RDebug::Printf("%sANY\n", pfx);

  1107      return;

  1108      }

  1109      if (gst_caps_is_empty (caps)) {

  1110      RDebug::Printf("%sEMPTY\n", pfx);

  1111      return;

  1112      }

  1113      const gchar *c;

  1114      for (i = 0; i < gst_caps_get_size (caps); i++) {

  1115      GstStructure *structure = gst_caps_get_structure (caps, i);

  1116      

  1117      RDebug::Printf("%s%s\n", pfx,c = gst_structure_get_name (structure));

  1118      

  1119      TPtrC8 fmt((const TText8*)c);

  1120    

  1121      TBuf<25> name;

  1122      name.Copy(fmt);

  1123     

  1124      iGstView->DrawText(name,KRgbBlack);

  1125          

  1126      gst_structure_foreach (structure, print_field, (gpointer) pfx);

  1127      }

  1128      }

  1129  

  1130  void getsinkpadcaps()

  1131      {

  1132      RDebug::Print(_L("Devsound Pad Caps"));

  1133      if(!sink)

  1134           {