Changeset 4016

Timestamp:

Apr 4, 2012 5:05:50 AM (13 years ago)

Author:

bennylp

Message:

Fixed #1478: AVI player virtual device. Initial spec:

• Currently only Works with raw video and audio AVI files
• Added --play-avi and --auto-play-avi options in pjsua
• No A/V synchronization yet

Location:

pjproject/trunk

Files:

• pjmedia/build/Makefile (modified) (1 diff)
• pjmedia/include/pjmedia-videodev/avi_dev.h (added)
• pjmedia/include/pjmedia-videodev/config.h (modified) (1 diff)
• pjmedia/include/pjmedia-videodev/videodev.h (modified) (4 diffs)
• pjmedia/include/pjmedia-videodev/videodev_imp.h (modified) (1 diff)
• pjmedia/include/pjmedia_videodev.h (modified) (1 diff)
• pjmedia/src/pjmedia-videodev/avi_dev.c (added)
• pjmedia/src/pjmedia-videodev/videodev.c (modified) (5 diffs)
• pjsip-apps/src/pjsua/pjsua_app.c (modified) (11 diffs)
• pjsip/include/pjsua-lib/pjsua.h (modified) (1 diff)

pjproject/trunk/pjmedia/build/Makefile

@@ -90 +90 @@
 #
 export PJMEDIA_VIDEODEV_SRCDIR = ../src/pjmedia-videodev
-export PJMEDIA_VIDEODEV_OBJS +=  errno.o videodev.o ffmpeg_dev.o \
+export PJMEDIA_VIDEODEV_OBJS +=  errno.o videodev.o avi_dev.o ffmpeg_dev.o \
                                 colorbar_dev.o v4l2_dev.o
 export PJMEDIA_VIDEODEV_CFLAGS += $(_CFLAGS)

pjproject/trunk/pjmedia/include/pjmedia-videodev/config.h

@@ -123 +123 @@
 #endif
 
+
+/**
+ * Enable support for AVI player virtual capture device.
+ *
+ * Default: 1
+ */
+#ifndef PJMEDIA_VIDEO_DEV_HAS_AVI
+#   define PJMEDIA_VIDEO_DEV_HAS_AVI            1
+#endif
+
+
 /**
  * @}

pjproject/trunk/pjmedia/include/pjmedia-videodev/videodev.h

@@ -560 +560 @@
 /**
  * Register a supported video device factory to the video device subsystem.
+ * Application can either register a function to create the factory, or
+ * an instance of an already created factory.
+ *
  * This function can only be called after calling
  * #pjmedia_vid_dev_subsys_init().
  *
- * @param vdf       The video device factory.
+ * @param vdf       The factory creation function. Either vdf or factory
+ *                  argument must be specified.
+ * @param factory   Factory instance. Either vdf or factory
+ *                  argument must be specified.
  *
  * @return          PJ_SUCCESS on successful operation or the appropriate
@@ -569 +575 @@
  */
 PJ_DECL(pj_status_t)
-pjmedia_vid_register_factory(pjmedia_vid_dev_factory_create_func_ptr vdf);
+pjmedia_vid_register_factory(pjmedia_vid_dev_factory_create_func_ptr vdf,
+                             pjmedia_vid_dev_factory *factory);
 
 
@@ -578 +585 @@
  * is currently in use, then the behavior is undefined.
  *
- * @param vdf       The video device factory.
+ * @param vdf       The video device factory. Either vdf or factory argument
+ *                  must be specified.
+ * @param factory   The factory instance. Either vdf or factory argument
+ *                  must be specified.
  *
  * @return          PJ_SUCCESS on successful operation or the appropriate
@@ -584 +594 @@
  */
 PJ_DECL(pj_status_t)
-pjmedia_vid_unregister_factory(pjmedia_vid_dev_factory_create_func_ptr vdf);
+pjmedia_vid_unregister_factory(pjmedia_vid_dev_factory_create_func_ptr vdf,
+                               pjmedia_vid_dev_factory *factory);
 
 

pjproject/trunk/pjmedia/include/pjmedia-videodev/videodev_imp.h

@@ -192 +192 @@
 
 
-
+/**
+ * Internal API: return the factory instance and device index that's local
+ * to the factory for a given device ID.
+ *
+ * @param id            Device id.
+ * @param p_f           Out: factory instance
+ * @param p_local_index Out: device index within the factory
+ *
+ * @return              PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t)
+pjmedia_vid_dev_get_local_index(pjmedia_vid_dev_index id,
+                                pjmedia_vid_dev_factory **p_f,
+                                unsigned *p_local_index);
+
+/**
+ * Internal API: return the global device index given a factory instance and
+ * a local device index.
+ *
+ * @param f             Factory.
+ * @param local_idx     Local index.
+ * @param pid           Returned global index.
+ *
+ * @return              PJ_SUCCESS on success.
+ */
+PJ_DEF(pj_status_t)
+pjmedia_vid_dev_get_global_index(const pjmedia_vid_dev_factory *f,
+                                 unsigned local_idx,
+                                 pjmedia_vid_dev_index *pid);
 
 /**

pjproject/trunk/pjmedia/include/pjmedia_videodev.h

@@ -27 +27 @@
 #include <pjmedia-videodev/videodev.h>
 #include <pjmedia-videodev/videodev_imp.h>
+#include <pjmedia-videodev/avi_dev.h>
 
 #endif  /* __PJMEDIA_VIDEODEV_H__ */

pjproject/trunk/pjmedia/src/pjmedia-videodev/videodev.c

@@ -408 +408 @@
 /* API: register a video device factory to the video device subsystem. */
 PJ_DEF(pj_status_t)
-pjmedia_vid_register_factory(pjmedia_vid_dev_factory_create_func_ptr adf)
-{
+pjmedia_vid_register_factory(pjmedia_vid_dev_factory_create_func_ptr adf,
+                             pjmedia_vid_dev_factory *factory)
+{
+    pj_bool_t refresh = PJ_FALSE;
     pj_status_t status;
 
@@ -416 +418 @@
 
     vid_subsys.drv[vid_subsys.drv_cnt].create = adf;
-    status = init_driver(vid_subsys.drv_cnt, PJ_FALSE);
+    vid_subsys.drv[vid_subsys.drv_cnt].f = factory;
+
+    if (factory) {
+        /* Call factory->init() */
+        status = factory->op->init(factory);
+        if (status != PJ_SUCCESS) {
+            factory->op->destroy(factory);
+            return status;
+        }
+        refresh = PJ_TRUE;
+    }
+
+    status = init_driver(vid_subsys.drv_cnt, refresh);
     if (status == PJ_SUCCESS) {
         vid_subsys.drv_cnt++;
@@ -428 +442 @@
 /* API: unregister a video device factory from the video device subsystem. */
 PJ_DEF(pj_status_t)
-pjmedia_vid_unregister_factory(pjmedia_vid_dev_factory_create_func_ptr adf)
+pjmedia_vid_unregister_factory(pjmedia_vid_dev_factory_create_func_ptr adf,
+                               pjmedia_vid_dev_factory *factory)
 {
     unsigned i, j;
@@ -438 +453 @@
         struct driver *drv = &vid_subsys.drv[i];
 
-        if (drv->create == adf) {
+        if ((factory && drv->f==factory) || (adf && drv->create == adf)) {
             for (j = drv->start_idx; j < drv->start_idx + drv->dev_cnt; j++)
             {
@@ -579 +594 @@
 }
 
+/* API: lookup device id */
+PJ_DEF(pj_status_t)
+pjmedia_vid_dev_get_local_index(pjmedia_vid_dev_index id,
+                                pjmedia_vid_dev_factory **p_f,
+                                unsigned *p_local_index)
+{
+    return lookup_dev(id, p_f, p_local_index);
+}
+
+/* API: from factory and local index, get global index */
+PJ_DEF(pj_status_t)
+pjmedia_vid_dev_get_global_index(const pjmedia_vid_dev_factory *f,
+                                 unsigned local_idx,
+                                 pjmedia_vid_dev_index *pid)
+{
+    PJ_ASSERT_RETURN(f->sys.drv_idx >= 0 && f->sys.drv_idx < MAX_DRIVERS,
+                     PJ_EINVALIDOP);
+    *pid = local_idx;
+    return make_global_index(f->sys.drv_idx, pid);
+}
+
 /* API: Get device information. */
 PJ_DEF(pj_status_t) pjmedia_vid_dev_get_info(pjmedia_vid_dev_index id,

pjproject/trunk/pjsip-apps/src/pjsua/pjsua_app.c

@@ -44 +44 @@
 #define RING_INTERVAL       3000
 
+#define MAX_AVI             4
 
 /* Call specific data */
@@ -136 +137 @@
     struct app_vid          vid;
     unsigned                aud_cnt;
+
+    /* AVI to play */
+    unsigned                avi_cnt;
+    pj_str_t                avi[MAX_AVI];
+    pj_bool_t               avi_auto_play;
+    pjmedia_vid_dev_index   avi_dev_id;
+    pjsua_conf_port_id      avi_slot;
 } app_config;
 
@@ -330 +338 @@
     puts  ("  --vcapture-dev=id   Video capture device ID (default=-1)");
     puts  ("  --vrender-dev=id    Video render device ID (default=-1)");
+    puts  ("  --play-avi=FILE     Load this AVI as virtual capture device");
+    puts  ("  --auto-play-avi     Automatically play the AVI media to call");
 #endif
 
@@ -400 +410 @@
     cfg->ringback_slot = PJSUA_INVALID_ID;
     cfg->ring_slot = PJSUA_INVALID_ID;
+
+    cfg->avi_dev_id = PJMEDIA_VID_INVALID_DEV;
+    cfg->avi_slot = PJSUA_INVALID_ID;
 
     for (i=0; i<PJ_ARRAY_SIZE(cfg->acc_cfg); ++i)
@@ -577 +590 @@
            OPT_TIMER, OPT_TIMER_SE, OPT_TIMER_MIN_SE,
            OPT_VIDEO, OPT_EXTRA_AUDIO,
-           OPT_VCAPTURE_DEV, OPT_VRENDER_DEV,
+           OPT_VCAPTURE_DEV, OPT_VRENDER_DEV, OPT_PLAY_AVI, OPT_AUTO_PLAY_AVI
     };
     struct pj_getopt_option long_options[] = {
@@ -703 +716 @@
         { "vcapture-dev", 1, 0, OPT_VCAPTURE_DEV},
         { "vrender-dev",  1, 0, OPT_VRENDER_DEV},
+        { "play-avi",   1, 0, OPT_PLAY_AVI},
+        { "auto-play-avi", 0, 0, OPT_AUTO_PLAY_AVI},
         { NULL, 0, 0, 0}
     };
@@ -1496 +1511 @@
             cfg->vid.vrender_dev = atoi(pj_optarg);
             cur_acc->vid_rend_dev = cfg->vid.vrender_dev;
+            break;
+
+        case OPT_PLAY_AVI:
+            if (app_config.avi_cnt >= MAX_AVI) {
+                PJ_LOG(1,(THIS_FILE, "Too many AVIs"));
+                return -1;
+            }
+            app_config.avi[app_config.avi_cnt++] = pj_str(pj_optarg);
+            break;
+
+        case OPT_AUTO_PLAY_AVI:
+            app_config.avi_auto_play = PJ_TRUE;
             break;
 
@@ -2082 +2109 @@
     if (config->vid.vrender_dev != PJMEDIA_VID_DEFAULT_RENDER_DEV) {
         pj_ansi_sprintf(line, "--vrender-dev %d\n", config->vid.vrender_dev);
+        pj_strcat2(&cfg, line);
+    }
+    for (i=0; i<config->avi_cnt; ++i) {
+        pj_ansi_sprintf(line, "--play-avi %s\n", config->avi[i].ptr);
+        pj_strcat2(&cfg, line);
+    }
+    if (config->avi_auto_play) {
+        pj_ansi_sprintf(line, "--auto-play-avi\n");
         pj_strcat2(&cfg, line);
     }
@@ -2788 +2823 @@
             pjsua_conf_connect(app_config.wav_port, call_conf_slot);
             connect_sound = PJ_FALSE;
+        }
+
+        /* Stream AVI, if desired */
+        if (app_config.avi_auto_play &&
+            app_config.avi_slot != PJSUA_INVALID_ID)
+        {
+            pjsua_conf_connect(app_config.avi_slot, call_conf_slot);
         }
 
@@ -3976 +4018 @@
     acc_cfg->vid_cap_dev = app_config.vid.vcapture_dev;
     acc_cfg->vid_rend_dev = app_config.vid.vrender_dev;
+
+    if (app_config.avi_auto_play &&
+        app_config.avi_dev_id != PJMEDIA_VID_INVALID_DEV)
+    {
+        acc_cfg->vid_cap_dev = app_config.avi_dev_id;
+    }
 }
 
@@ -5636 +5684 @@
     }
 
+    /* Create AVI player virtual devices */
+    if (app_config.avi_cnt) {
+#if PJMEDIA_VIDEO_DEV_HAS_AVI
+        pjmedia_vid_dev_factory *avi_factory;
+
+        status = pjmedia_avi_dev_create_factory(pjsua_get_pool_factory(),
+                                                app_config.avi_cnt,
+                                                &avi_factory);
+        if (status != PJ_SUCCESS) {
+            PJ_PERROR(1,(THIS_FILE, status, "Error creating AVI factory"));
+            goto on_error;
+        }
+
+        for (i=0; i<app_config.avi_cnt; ++i) {
+            pjmedia_avi_dev_param avdp;
+            pjmedia_vid_dev_index avid;
+            unsigned strm_idx, strm_cnt;
+
+            pjmedia_avi_dev_param_default(&avdp);
+            avdp.path = app_config.avi[i];
+
+            status =  pjmedia_avi_dev_alloc(avi_factory, &avdp, &avid);
+            if (status != PJ_SUCCESS) {
+                PJ_PERROR(1,(THIS_FILE, status,
+                             "Error creating AVI player for %.*s",
+                             (int)avdp.path.slen, avdp.path.ptr));
+                goto on_error;
+            }
+
+            PJ_LOG(4,(THIS_FILE, "AVI player %.*s created, dev_id=%d",
+                      (int)avdp.title.slen, avdp.title.ptr, avid));
+            app_config.avi_dev_id = avid;
+
+            strm_cnt = pjmedia_avi_streams_get_num_streams(avdp.avi_streams);
+            for (strm_idx=0; strm_idx<strm_cnt; ++strm_idx) {
+                pjmedia_port *aud;
+                pjmedia_format *fmt;
+                pjsua_conf_port_id slot;
+                char fmt_name[5];
+
+                aud = pjmedia_avi_streams_get_stream(avdp.avi_streams,
+                                                     strm_idx);
+                fmt = &aud->info.fmt;
+
+                pjmedia_fourcc_name(fmt->id, fmt_name);
+
+                if (fmt->id == PJMEDIA_FORMAT_PCM) {
+                    status = pjsua_conf_add_port(app_config.pool, aud,
+                                                 &slot);
+                    if (status == PJ_SUCCESS) {
+                        PJ_LOG(4,(THIS_FILE,
+                                  "AVI %.*s: audio added to slot %d",
+                                  (int)avdp.title.slen, avdp.title.ptr,
+                                  slot));
+                        app_config.avi_slot = slot;
+                    }
+                } else {
+                    PJ_LOG(4,(THIS_FILE,
+                              "AVI %.*s: audio ignored, format=%s",
+                              (int)avdp.title.slen, avdp.title.ptr,
+                              fmt_name));
+                }
+            }
+        }
+#else
+        PJ_LOG(2,(THIS_FILE,
+                  "Warning: --play-avi is ignored because AVI is disabled"));
+#endif  /* PJMEDIA_VIDEO_DEV_HAS_AVI */
+    }
+
     /* Add UDP transport unless it's disabled. */
     if (!app_config.no_udp) {

pjproject/trunk/pjsip/include/pjsua-lib/pjsua.h

@@ -35 +35 @@
 /* Include all PJMEDIA-CODEC headers. */
 #include <pjmedia-codec.h>
+
+/* Videodev too */
+#include <pjmedia_videodev.h>
 
 /* Include all PJSIP-UA headers */