linux下webcam进行录像， gstreamer架构

author: CarlsonLee([email protected]), 本代码是freecamera的一部分，freecamera源代码存在：http://gitorious.org/freecamera

#include <glib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <gst/gst.h>
#include <gst/app/gstappsink.h>
#include <gst/app/gstappsrc.h>
#include <gst/app/gstappbuffer.h>

#include "cam_midware.h"
#include "cam_global.h"
#include "cam_display.h"
#include "cam_files.h"
#include "color_space.h"
#include "review_data.h"
#include "cam_ui.h"
#include "cam_utils.h"
#include "cam_err.h"

#define SKIP_FRAMES 10
static struct tag_CAM_MW_DATA
{
    gint               camera_status;
    GMainLoop*      video_cap_loop;
    char*            filename;
    gint             skip_frames;
    GMutex*            mutex;
}cam_video_data;

static gboolean video_bus_call (GstBus     *bus,
                       GstMessage *msg,
                       gpointer    data)
{
    GMainLoop *loop = (GMainLoop *) data;

    bus = bus;
    switch (GST_MESSAGE_TYPE (msg))
    {
    case GST_MESSAGE_EOS:
        g_main_loop_quit (loop);
        break;
    case GST_MESSAGE_ERROR:
        {
            gchar *debug;
            GError *error;
            gst_message_parse_error (msg, &error, &debug);
            g_print ("Error**##: %s, %s\n", error->message, debug);
            g_free (debug);
            g_error_free (error);
            g_main_loop_quit (loop);
        }
        break;
    default:
        break;
    }
    return TRUE;
}

static gboolean link_video_cap_src(GstElement *src, GstElement *sink)
{
    gboolean link_ok = FALSE;
    GstCaps *caps;
      guint width = cam_global_data.cam_res.video_res[cam_global_data.cam_res.video_res_cur].width;
    guint height = cam_global_data.cam_res.video_res[cam_global_data.cam_res.video_res_cur].height;
    caps = gst_caps_new_simple ("video/x-raw-yuv",
            "width", G_TYPE_INT, width,
            "height", G_TYPE_INT, height, NULL);
    link_ok = gst_element_link_filtered (src, sink, caps);
    gst_caps_unref (caps);
    return link_ok;
}

static gboolean link_video_cap_pp(GstElement *src, GstElement *sink)
{
    gboolean link_ok = FALSE;
    GstCaps *caps;
 
      guint width = cam_global_data.cam_res.video_res[cam_global_data.cam_res.video_res_cur].width;
      guint height = cam_global_data.cam_res.video_res[cam_global_data.cam_res.video_res_cur].height;

    caps = gst_caps_new_simple ("video/x-raw-yuv",
            "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
            "width", G_TYPE_INT, width,
            "height", G_TYPE_INT, height, NULL);

    link_ok = gst_element_link_filtered (src, sink, caps);
    gst_caps_unref (caps);
    return link_ok;
}

static gboolean link_video_cap_enc(GstElement *src, GstElement *sink)
{
    gboolean link_ok = FALSE;
    GstCaps *caps;
 
      guint width = cam_global_data.cam_res.video_res[cam_global_data.cam_res.video_res_cur].width;
      guint height = cam_global_data.cam_res.video_res[cam_global_data.cam_res.video_res_cur].height;

    caps = gst_caps_new_simple ("video/x-raw-yuv",
            "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
            "framerate", GST_TYPE_FRACTION, 30, 1,
            "width", G_TYPE_INT, width,
            "height", G_TYPE_INT, height, NULL);

    link_ok = gst_element_link_filtered (src, sink, caps);
    gst_caps_unref (caps);
    return link_ok;
}

gint getTickCount()
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}

static gint frames = 0;
static long last_time = 0;
static void raw_captured(void* data, guint size, guint64 timestamp)
{
      guint width = cam_global_data.cam_res.video_res[cam_global_data.cam_res.video_res_cur].width;
      guint height = cam_global_data.cam_res.video_res[cam_global_data.cam_res.video_res_cur].height;
      
      if(cam_global_data.photo_timestamp)
          camui_mask_timestamp(data, width, height);
          
      if(cam_video_data.skip_frames--<=0)
      {
          void* review_data = malloc(cam_global_data.preview_data_width*cam_global_data.preview_data_height*3/2);
          timestamp = timestamp;
          if(review_data == NULL)
              return;
          if(width != cam_global_data.preview_data_width || height != cam_global_data.preview_data_height)
          {
              resample_yv12(review_data,
                          cam_global_data.preview_data_width,
                          cam_global_data.preview_data_height,
                          data, width, height, SCALE_TYPE_BILINEAR);
          }
          else
          {
              memcpy(review_data, data, cam_global_data.preview_data_width*cam_global_data.preview_data_height*3/2);
          }
          camrev_append(review_data, cam_video_data.filename);
      }
      frames++;
      if(frames%30==0)
      {
          g_print("fps: %ld\n", 30000/(getTickCount()-last_time));
          last_time = getTickCount();
          frames = 0;
      }
      camdisp_show(data,
                  width*height*3/2,
                  width,
                  height);

      cam_global_data.video_rec_time = timestamp/1000000000;
}

void* video_cap_thread(void* param)
{
    const char* cam_dev_file = cam_global_data.cam_dev_list->cam_device[cam_global_data.cam_dev_list->current_device].device;
    GstBus      *video_cap_bus = NULL;
    GstElement  *video_cap_pipeline = NULL;
    GstElement     *video_cap_bin = NULL;
    GstElement  *video_cap_src = NULL;
    GstElement     *video_cap_pp = NULL;
    GstElement     *video_cap_trans = NULL;
    GstElement     *video_cap_enc = NULL;
    GstElement     *video_cap_mux = NULL;
    GstElement     *video_cap_sink = NULL;
    GstElement     *audio_cap_src = NULL;
      GstElement     *audio_cap_enc = NULL;
      
      GstPad *srcpad = NULL;
    GstPad *sinkpad = NULL;
    
    GstPadLinkReturn lres;

      gboolean ret = FALSE;
      cam_global_data.is_capturing = TRUE;
      cam_video_data.skip_frames = SKIP_FRAMES;
    cammw_stop_preview();
    camrev_init(cam_global_data.preview_data_width, cam_global_data.preview_data_height);
    cam_video_data.video_cap_loop = g_main_loop_new (NULL, FALSE);
          
    video_cap_pipeline = gst_pipeline_new ("video_cap");
    if(!video_cap_pipeline)
    {
        g_print("%s, %d\n", __FUNCTION__, __LINE__);  
        goto exit;
    }
    video_cap_bus = gst_pipeline_get_bus (GST_PIPELINE (video_cap_pipeline));
    gst_bus_add_watch (video_cap_bus, video_bus_call, cam_video_data.video_cap_loop);
    gst_object_unref (video_cap_bus);
    
    video_cap_bin     = gst_bin_new("video_cap_bin");
    video_cap_src    = gst_element_factory_make ("v4l2src",    "video_cap_src");
    video_cap_pp    = gst_element_factory_make ("ffmpegcolorspace",    "video_pp");
    video_cap_trans = gst_element_factory_make ("camgrub","video_enc_trans");
    video_cap_enc   = gst_element_factory_make ("theoraenc","video_enc");
    video_cap_mux   = gst_element_factory_make ("oggmux","video_mux");
    video_cap_sink  = gst_element_factory_make ("filesink","video_writer");
    audio_cap_src  = gst_element_factory_make ("pulsesrc","audio_cap_src");
    audio_cap_enc  = gst_element_factory_make ("vorbisenc","audio_cap_enc");
    if ( !video_cap_bin ||
        !video_cap_src ||
        !video_cap_pp ||
        !video_cap_trans||
        !video_cap_enc ||
        !video_cap_mux ||
        !video_cap_sink ||
        !audio_cap_src ||
        !audio_cap_enc
        )
    {
        g_printerr ("One element in capture bin could not be created. Exiting.\n");
        goto exit ;
    }
    g_object_set (G_OBJECT (video_cap_src), "device", cam_dev_file, NULL);
    g_object_set (G_OBJECT (video_cap_trans), "captured", (guint)raw_captured, NULL);
    cam_video_data.filename = g_strdup(camfiles_get_video_full_name());
    g_object_set (G_OBJECT (video_cap_sink), "location", cam_video_data.filename, NULL);
    gst_bin_add_many (GST_BIN (video_cap_bin),
                     video_cap_src,
                     video_cap_pp,
                     video_cap_trans,
                     video_cap_enc,
                     video_cap_mux,
                     video_cap_sink,
                     audio_cap_src,
                     audio_cap_enc,
                       NULL);
    
    gst_bin_add (GST_BIN (video_cap_pipeline), video_cap_bin);
    if(!link_video_cap_src (video_cap_src, video_cap_pp))
    {
          g_print("link camera src element failed\n");
        goto exit;
    }
    if(!link_video_cap_pp (video_cap_pp, video_cap_trans))
    {
          g_print("link camera pp element failed\n");
        goto exit;
    }
      if(!link_video_cap_enc( video_cap_trans, video_cap_enc))
      {
         g_print("link camera video enc elements failed\n");
       goto exit;
      }
       /*if(!gst_element_link_many (video_cap_pp, video_cap_enc, NULL))
      {
         g_print("link camera audio enc elements failed\n");
       goto exit;
      }*/          
      
      if(!gst_element_link_many ( audio_cap_src, audio_cap_enc, NULL))
      {
         g_print("link camera audio enc elements failed\n");
       goto exit;
      }         
      
      sinkpad = gst_element_get_request_pad (video_cap_mux, "sink_0");
    srcpad = gst_element_get_static_pad (video_cap_enc, "src");
    lres = gst_pad_link (srcpad, sinkpad);
    if(lres != GST_PAD_LINK_OK)
    {
          g_print("link camera video mux elements failed\n");
          goto exit;
    }
    //gst_element_release_request_pad(video_cap_mux, sinkpad);
    gst_object_unref (srcpad);
    
      sinkpad = gst_element_get_request_pad (video_cap_mux, "sink_1");
    srcpad = gst_element_get_static_pad (audio_cap_enc, "src");
    lres = gst_pad_link (srcpad, sinkpad);
    gst_object_unref (srcpad);
    if(lres != GST_PAD_LINK_OK)
    {
          g_print("link camera audio mux elements failed\n");
          goto exit;
    }
    
       if(!gst_element_link_many ( video_cap_mux, video_cap_sink, NULL))
      {
         g_print("link camera video filesink elements failed\n");
       goto exit;
      }         
 
    gst_element_set_state (video_cap_pipeline, GST_STATE_PLAYING);
    cam_video_data.camera_status = CAM_STATUS_RUNNING;
    g_mutex_unlock(cam_video_data.mutex);
    camutils_play_record_sound();
    g_main_loop_run(cam_video_data.video_cap_loop);
    gst_element_set_state (video_cap_pipeline, GST_STATE_NULL);
    camutils_play_record_sound();    
    ret = TRUE;
exit:
    if(video_cap_pipeline)
        gst_object_unref (GST_OBJECT (video_cap_pipeline));
    if(cam_video_data.video_cap_loop)
        g_main_loop_unref(cam_video_data.video_cap_loop);    
    if(cam_video_data.filename)
        g_free(cam_video_data.filename);
    cam_video_data.camera_status = CAM_STATUS_STOPPED;
    if(!ret)
    {
        camui_show_error_message(CERR_FAILED_RECORD_VIDEO);
        cam_global_data.is_capturing = FALSE;
        g_mutex_unlock(cam_video_data.mutex);
    }
    return NULL;
}

gboolean cammw_start_record_video()
{
    pthread_t thread_id;
    pthread_attr_t attr;
    if(cam_video_data.camera_status == CAM_STATUS_RUNNING)
        return FALSE;
    memset(&cam_video_data, 0, sizeof(cam_video_data));
    cam_video_data.mutex=g_mutex_new();
    g_mutex_lock(cam_video_data.mutex);
    pthread_attr_init(&attr);
    pthread_create(&thread_id,NULL,video_cap_thread,NULL);
    while(!g_mutex_trylock(cam_video_data.mutex))
    {
        usleep(100000);
    }
    g_mutex_unlock(cam_video_data.mutex);
    if(cam_video_data.camera_status == CAM_STATUS_STOPPED)
    {
        g_mutex_free(cam_video_data.mutex);
           if(cam_video_data.video_cap_loop)
            g_main_loop_unref(cam_video_data.video_cap_loop);
        memset(&cam_video_data, 0, sizeof(cam_video_data));
        return FALSE;
    }
    return TRUE;
}

gboolean cammw_stop_record_video()
{
    if(cam_video_data.camera_status != CAM_STATUS_RUNNING)
        return TRUE;
    g_mutex_free(cam_video_data.mutex);
    g_main_loop_quit (cam_video_data.video_cap_loop);
    memset(&cam_video_data, 0, sizeof(cam_video_data));
    cam_global_data.is_capturing = FALSE;
    return TRUE;
}