playback.c

本程序使用gstreamer实现音视频播放,。

//////////////////////////////////////////////////
void set_video_saturation(int value)
{
  video_local_get_video_property (VIDEO_SATURATION);
  video_local_set_video_property (VIDEO_SATURATION, value);
}

///////////////////////////////////////////////////
//descriptor: set hue for video.
//para:
//return value:
//////////////////////////////////////////////////
void set_video_hue(int value)
{
  video_local_get_video_property (VIDEO_HUE);
  video_local_set_video_property (VIDEO_HUE, value);
}

//////////////////////////////////////////////////////////////////////////////////////////
//play / pause / play      
//return 0 is success   <0 is failure
///////////////////////////////////////////////////
//descriptor: start playback.
//para:
//return value:
//////////////////////////////////////////////////
gint start_playback()
{
  GstStateChangeReturn res;
  printf("	++++ %s ++++\n", __func__);
  if(media.play_state == GST_PAUSE && media.g_pipe)
  {
    res = gst_element_set_state (media.g_pipe, GST_STATE_PLAYING);
    if (res == GST_STATE_CHANGE_FAILURE)
    {
      g_print ("could not play. \n");
      return -1;
    }
    else
    {
      media.play_state = GST_PLAY;
    }
  }
  else if (media.play_state == GST_STOP)
  {
    
  }
  	
  return 0;
}

///////////////////////////////////////////////////
//descriptor: pause playback.
//para:
//return value:
//////////////////////////////////////////////////
gint pause_playback()
{
  GstStateChangeReturn res;
  printf("	++++ %s ++++\n", __func__);
  if(media.g_pipe)
  {    
    if(media.play_state == GST_PLAY)
    {
      res = gst_element_set_state (media.g_pipe, GST_STATE_PAUSED);
      if (res == GST_STATE_CHANGE_FAILURE)
      {
        g_print ("could not pause. \n");
        return -1;
      }
      else
      {
        media.play_state = GST_PAUSE;
      }
    }
  }
  return 0;
}

///////////////////////////////////////////////////
//descriptor: stop playback.
//para:
//return value:
//////////////////////////////////////////////////
gint  stop_playback()
{
  GstStateChangeReturn res;
  printf("	++++ %s ++++\n", __func__);
  if(media.g_pipe)
  {
    if(media.play_state == GST_PAUSE | media.play_state == GST_PLAY)
    {
      res = gst_element_set_state (media.g_pipe, GST_STATE_NULL);
      if (res == GST_STATE_CHANGE_FAILURE)
      {
        g_print ("could not stop. \n");
        return -1;
      }
      else
      {
        gst_object_unref (GST_OBJECT (media.g_pipe));
        media.g_pipe = NULL;
        media.play_state = GST_STOP;
      }
    }
  }
  return 0;
}



//////////////////////////////////////////////////////////////////////////////////////////
//get caps.
///////////////////////////////////////////////////
//descriptor: message process for caps.
//para:
//return value:
//////////////////////////////////////////////////
static gboolean message_loop (GstElement * element, GstTagList ** tags)
{
  GstBus *bus;
  gboolean done = FALSE;

  printf("	++++ %s ++++\n", __func__);
  bus = gst_element_get_bus (element);
  g_return_val_if_fail (bus != NULL, FALSE);
  g_return_val_if_fail (tags != NULL, FALSE);

  while (!done) 
  {
    GstMessage *message;

    message = gst_bus_pop (bus);
    if (message == NULL)  /* All messages read, we're done */
      break;

    switch (GST_MESSAGE_TYPE (message)) 
    {
      case GST_MESSAGE_ERROR:
      case GST_MESSAGE_EOS:
        gst_message_unref (message);
        return TRUE;
    
      case GST_MESSAGE_TAG:
      {
        GstTagList *new_tags;

        gst_message_parse_tag (message, &new_tags);
        if (*tags)
          *tags = gst_tag_list_merge (*tags, new_tags, GST_TAG_MERGE_KEEP_ALL);
        else
          *tags = new_tags;
        break;
      }
    
      default:
        break;
    }
    gst_message_unref (message);
  }
  gst_object_unref (bus);
  return TRUE;
}

///////////////////////////////////////////////////
//descriptor: make a pipeline for caps.
//para:
//return value:
//////////////////////////////////////////////////
static void make_pipeline (GstElement **pipeline, GstElement **source)
{
  GstElement *decodebin;

  printf("	++++ %s ++++\n", __func__);
  if (*pipeline != NULL)
  {
    gst_object_unref (*pipeline);
  }

  *pipeline = gst_pipeline_new (NULL);
  *source = gst_element_factory_make ("filesrc", "source");
  g_assert (GST_IS_ELEMENT (*source));
  
  decodebin = gst_element_factory_make ("decodebin", "decodebin");
  g_assert (GST_IS_ELEMENT (decodebin));

  gst_bin_add_many (GST_BIN (*pipeline), *source, decodebin, NULL);
  gst_element_link (*source, decodebin);
}

///////////////////////////////////////////////////
//descriptor: get caps and output the content.
//para:
//return value:
//////////////////////////////////////////////////
static void print_tag (const GstTagList * list, const gchar * tag, gpointer unused)
{
  gint i, count;

  printf("	++++ %s ++++\n", __func__);
  count = gst_tag_list_get_tag_size (list, tag);
  g_print("the count is: %d\n", count);
  for (i = 0; i < count; i++) 
  {
    gchar *str;
    //gchar name1;

    if (gst_tag_get_type (tag) == G_TYPE_STRING) 
    {
      if (!gst_tag_list_get_string_index (list, tag, i, &str))
      {
        g_assert_not_reached ();
      }
    } 
    else 
    {
      str = g_strdup_value_contents (gst_tag_list_get_value_index (list, tag, i));
    }

    if (i == 0) 
    {
      g_print ("  %15s: %s\n", gst_tag_get_nick (tag), str);
    } 
    else 
    {
      g_print ("                 : %s\n", str);
    }
    g_free (str);
  }
}

///////////////////////////////////////////////////
//descriptor: get caps of streaming.
//para:
//return value:
//////////////////////////////////////////////////
gboolean getCaps(gchar *file)	
{
  guint i = 1;
  char *filename = NULL;
  GstElement *capsbin = NULL; 
  GstElement *source = NULL;
  
  printf("	++++ %s ++++\n", __func__);
  //gst_init (NULL, NULL);
  make_pipeline (&capsbin, &source);
  GstStateChangeReturn sret;
  GstState state;
  GstTagList *tags = NULL;
  //gchar *name;


  filename = file;
  g_object_set (source, "location", filename, NULL);

  GST_DEBUG ("Starting reading for %s", filename);

  /* Decodebin will only commit to PAUSED if it actually finds a type;
   * otherwise the state change fails */
  sret = gst_element_set_state (GST_ELEMENT (capsbin), GST_STATE_PAUSED);

  if (GST_STATE_CHANGE_ASYNC == sret) 
  {
      if (GST_STATE_CHANGE_SUCCESS !=
          gst_element_get_state (GST_ELEMENT (capsbin), &state, NULL,
              5 * GST_SECOND)) {
        g_print ("State change failed for %s. Aborting\n", filename);        
        if (capsbin)
        {
          gst_object_unref (capsbin);
        }
      }
  } 
  else if (sret != GST_STATE_CHANGE_SUCCESS) 
  {
      g_print ("%s - Could not read file\n", filename);      
      if (capsbin)
      {
        gst_object_unref (capsbin);
      }
  }

  if (!message_loop (GST_ELEMENT (capsbin), &tags)) 
  {
      g_print ("Failed in message reading for %s\n", file);
  }

  if (tags) 
  {
      g_print ("Metadata for %s:\n", file);
      gst_tag_list_foreach (tags, print_tag, NULL);
      gst_tag_list_free (tags);
      tags = NULL;
      //g_print("+++++++name+++++++: %s\n", name);
  } 
  else
  {
      g_print ("No metadata found for %s\n", file);
  }
  sret = gst_element_set_state (GST_ELEMENT (capsbin), GST_STATE_NULL);
  if (sret == GST_STATE_CHANGE_ASYNC) 
  {
      if (GST_STATE_CHANGE_FAILURE == gst_element_get_state (GST_ELEMENT (capsbin), 
			      &state, NULL, GST_CLOCK_TIME_NONE)) 
      {
        g_print ("State change failed. Aborting");        
      }
  }
  if (capsbin)
  {
    gst_object_unref (capsbin);
  }
  return 0;
}


////////////////////////////////////////////////////////////////////////////////////////
//adjust volume 
///////////////////////////////////////////////////
//descriptor: 
//para:
//return value:
//////////////////////////////////////////////////
gboolean video_can_set_volume ()
{
  //g_return_val_if_fail (bvw != NULL, FALSE);
  //g_return_val_if_fail (BACON_IS_VIDEO_WIDGET (bvw), FALSE);
  //g_return_val_if_fail (GST_IS_ELEMENT (bvw->priv->play), FALSE);

  if (media.speakersetup == AUDIO_SOUND_AC3PASSTHRU)
    return FALSE;

  return !media.uses_fakesink;
}

///////////////////////////////////////////////////
//descriptor: get volume.
//para:
//return value:
//////////////////////////////////////////////////
int video_get_volume ()
{
  gdouble vol;

  //g_return_val_if_fail (bvw != NULL, -1);
  //g_return_val_if_fail (BACON_IS_VIDEO_WIDGET (bvw), -1);
  //g_return_val_if_fail (GST_IS_ELEMENT (bvw->priv->play), -1);

  g_object_get (G_OBJECT (media.g_pipe), "volume", &vol, NULL);

  return (gint) (vol * 100 + 0.5);
}

///////////////////////////////////////////////////
//descriptor: set volume
//para:
//return value:
//////////////////////////////////////////////////
void video_set_volume ( int volume)
{
  //g_return_if_fail ( != NULL);
  //g_return_if_fail (BACON_IS_VIDEO_WIDGET ());
  //g_return_if_fail (GST_IS_ELEMENT (priv->play));

  if (video_can_set_volume () != FALSE)
  {
    volume = CLAMP (volume, 0, 100);
    g_object_set (media.g_pipe, "volume",
                  (gdouble) (1. * volume / 100), NULL);
    //g_object_notify (G_OBJECT (), "volume");
  }
}
///////////////////////////////////////////////////
//descriptor: setting volume 
//para:
//return value:
//////////////////////////////////////////////////
void change_volume (int volume)
{
  int vol;

  if (video_can_set_volume () == FALSE)
    return;

  vol = video_get_volume ();
  video_set_volume (vol + volume);
}

///////////////////////////////////////////////////
//descriptor: volume add
//para:
//return value:
//////////////////////////////////////////////////
void adjust_volume_add()
{
  change_volume(VOLUME_ADD_OFFSET);  
}

///////////////////////////////////////////////////
//descriptor: volume subtract
//para:
//return value:
//////////////////////////////////////////////////
void adjust_volume_sub()
{
  change_volume(VOLUME_SUB_OFFSET);  
}