Changeset 3461

Timestamp:

Mar 17, 2011 11:33:34 AM (14 years ago)

Author:

bennylp

Message:

Re #1215 (framework):

• vstream:
  • allow NULL pool parameter which means vstream will create one
  • Updated remote FPS detection to only be performed if decoder returns frame (however the FPS detection is currently disabled as some endpoints changes fps continuously, causing renderer restart continuously too).
• codec:
  • Updated video codec info to have RTP packetization support flag, also update endpoint in generating SDP to only include codecs whose RTP packetization support.
  • Added dynamic payload types for video codecs.
  • (minor) separate video PT into separate enum in pjmedia-codec/types.h
• H264 initial experiment.

generated frames (for libx264 sake).

• Replaced PJ_EUNKNOWN in some places with the appropriate error code.

Location:

pjproject/branches/projects/2.0-dev/pjmedia

Files:

• include/pjmedia-codec/types.h (modified) (2 diffs)
• include/pjmedia/format.h (modified) (3 diffs)
• include/pjmedia/vid_codec.h (modified) (1 diff)
• include/pjmedia/vid_stream.h (modified) (2 diffs)
• src/pjmedia-codec/ffmpeg_codecs.c (modified) (14 diffs)
• src/pjmedia/endpoint.c (modified) (2 diffs)
• src/pjmedia/ffmpeg_util.c (modified) (1 diff)
• src/pjmedia/vid_stream.c (modified) (25 diffs)

pjproject/branches/projects/2.0-dev/pjmedia/include/pjmedia-codec/types.h

@@ -39 +39 @@
 
 /**
- * These are the dynamic payload types that are used by codecs in
+ * These are the dynamic payload types that are used by audio codecs in
  * this library. Also see the header file <pjmedia/codec.h> for list
  * of static payload types.
  */
-enum
+enum pjmedia_audio_pt
 {
     /* According to IANA specifications, dynamic payload types are to be in
@@ -99 +99 @@
 
 /**
+ * These are the dynamic payload types that are used by video codecs in
+ * this library.
+ */
+enum pjmedia_video_pt
+{
+     /* Video payload types */
+     PJMEDIA_RTP_PT_VID_START = (PJMEDIA_RTP_PT_DYNAMIC-1),
+     PJMEDIA_RTP_PT_H263P,
+     PJMEDIA_RTP_PT_H264,
+
+     /* Caution!
+      * Ensure the value of the last pt above is <= 127.
+      */
+};
+
+
+/**
  * @}
  */

pjproject/branches/projects/2.0-dev/pjmedia/include/pjmedia/format.h

@@ -183 +183 @@
     PJMEDIA_FORMAT_H263     = PJMEDIA_FORMAT_PACK('H', '2', '6', '3'),
     PJMEDIA_FORMAT_H263P    = PJMEDIA_FORMAT_PACK('P', '2', '6', '3'),
+    PJMEDIA_FORMAT_H264     = PJMEDIA_FORMAT_PACK('H', '2', '6', '4'),
 
     PJMEDIA_FORMAT_MJPEG    = PJMEDIA_FORMAT_PACK('M', 'J', 'P', 'G'),
@@ -443 +444 @@
                        clock_rate / channel_count / 1000000));
 #elif PJ_HAS_FLOATING_POINT
-    return ((unsigned)(usec_ptime * clock_rate / channel_count / 1000000.0));
+    return ((unsigned)(1.0*usec_ptime * clock_rate / channel_count / 1000000));
 #else
     return ((unsigned)(usec_ptime / 1000L * clock_rate / \
@@ -449 +450 @@
 #endif
 }
+
+/**
+ * Variant of #PJMEDIA_SPF() which takes frame rate instead of ptime.
+ */
+PJ_INLINE(unsigned) PJMEDIA_SPF2(unsigned clock_rate, const pjmedia_ratio *fr,
+                                 unsigned channel_count)
+{
+#if PJ_HAS_INT64
+    return ((unsigned)((pj_uint64_t)clock_rate * fr->num \
+                       / fr->denum / channel_count));
+#elif PJ_HAS_FLOATING_POINT
+    return ((unsigned)(1.0 * clock_rate * fr->num /fr->denum /channel_count));
+#else
+    return ((unsigned)(1L * clock_rate * fr->num / fr->denum / channel_count));
+#endif
+}
+
 
 /**

pjproject/branches/projects/2.0-dev/pjmedia/include/pjmedia/vid_codec.h

@@ -59 +59 @@
     pjmedia_ratio       fps[PJMEDIA_VID_CODEC_MAX_FPS_CNT];
                                         /**< Supported frame-rates          */
+    pj_bool_t           has_rtp_pack;   /**< Support RTP packetization      */
 } pjmedia_vid_codec_info;
 

pjproject/branches/projects/2.0-dev/pjmedia/include/pjmedia/vid_stream.h

@@ -160 +160 @@
  *
  * @param endpt         Media endpoint.
- * @param pool          Pool to allocate memory for the stream. A large
- *                      number of memory may be needed because jitter
+ * @param pool          Optional pool to allocate memory for the stream. If
+ *                      this is not specified, one will be created internally.
+ *                      A large number of memory may be needed because jitter
  *                      buffer needs to preallocate some storage.
- * @param info          Stream information.
- * @param tp            Stream transport instance used to transmit 
- *                      and receive RTP/RTCP packets to/from the underlying 
- *                      transport. 
+ * @param info          Stream information to create the stream. Upon return,
+ *                      this info will be updated with the information from
+ *                      the instantiated codec. Note that if the "pool"
+ *                      argument is NULL, some fields in this "info" parameter
+ *                      will be allocated from the internal pool of the
+ *                      stream, which means that they will only remain valid
+ *                      as long as the stream is not destroyed.
+ * @param tp            Media transport instance used to transmit and receive
+ *                      RTP/RTCP packets to/from the underlying network.
  * @param user_data     Arbitrary user data (for future callback feature).
  * @param p_stream      Pointer to receive the video stream.
@@ -175 +181 @@
                                         pjmedia_endpt *endpt,
                                         pj_pool_t *pool,
-                                        const pjmedia_vid_stream_info *info,
+                                        pjmedia_vid_stream_info *info,
                                         pjmedia_transport *tp,
                                         void *user_data,

pjproject/branches/projects/2.0-dev/pjmedia/src/pjmedia-codec/ffmpeg_codecs.c

@@ -246 +246 @@
 {
     {
-        {PJMEDIA_FORMAT_H263P,  {"H263-1998",9},    PJMEDIA_RTP_PT_H263},
+        {PJMEDIA_FORMAT_H263P,  {"H263-1998",9},    PJMEDIA_RTP_PT_H263P},
         PJMEDIA_FORMAT_H263,    1000000,    2000000,
         &h263_packetize, &h263_unpacketize, &h263_parse_fmtp,
@@ -258 +258 @@
     },
     {
+        {PJMEDIA_FORMAT_H264,   {"H264",4},         PJMEDIA_RTP_PT_H264},
+    },
+    {
         {PJMEDIA_FORMAT_H261,   {"H261",4},         PJMEDIA_RTP_PT_H261},
     },
@@ -264 +267 @@
     },
     {
-        {PJMEDIA_FORMAT_MPEG4,  {"MP4V",4},         PJMEDIA_RTP_PT_MPV},
+        {PJMEDIA_FORMAT_MPEG4,  {"MP4V",4}},
     },
     {
-        {PJMEDIA_FORMAT_XVID,   {"XVID",4},         PJMEDIA_RTP_PT_MPV},
+        {PJMEDIA_FORMAT_XVID,   {"XVID",4}},
         PJMEDIA_FORMAT_MPEG4,
     },
@@ -452 +455 @@
                 PJ_TODO(NOTIFY_APP_ABOUT_THIS_NEW_ENCODING_FORMAT);
             } else {
-                return PJ_EUNKNOWN;
+                return PJMEDIA_EBADFMT;
             }
         }
@@ -532 +535 @@
     avcodec_init();
     avcodec_register_all();
+    av_log_set_level(AV_LOG_ERROR);
 
     /* Enum FFMPEG codecs */
@@ -649 +653 @@
         if (desc->info.clock_rate == 0)
             desc->info.clock_rate = 90000;
+
+        /* Set RTP packetization support flag in the codec info */
+        desc->info.has_rtp_pack = (desc->packetize != NULL) &&
+                                  (desc->unpacketize != NULL);
     }
 
@@ -994 +1002 @@
             if (vfd->avg_bps) {
                 ctx->bit_rate = vfd->avg_bps;
-                if (vfd->max_bps)
+                if (vfd->max_bps > vfd->avg_bps)
                     ctx->bit_rate_tolerance = vfd->max_bps - vfd->avg_bps;
+            }
+
+            /* Libx264 experimental setting (it rejects ffmpeg defaults) */
+            if (ff->param.enc_fmt.id == PJMEDIA_FORMAT_H264) {
+                ctx->me_range = 16;
+                ctx->max_qdiff = 4;
+                ctx->qmin = 10;
+                ctx->qmax = 51;
+                ctx->qcompress = 0.6f;
             }
 
@@ -1027 +1044 @@
         if (err < 0) {
             print_ffmpeg_err(err);
-            return PJ_EUNKNOWN;
+            return PJMEDIA_CODEC_EFAILED;
         }
 
@@ -1219 +1236 @@
 
     avcodec_get_frame_defaults(&avframe);
+    avframe.pts = input->timestamp.u64;
     
     for (i = 0; i < ff->enc_vfi->plane_cnt; ++i) {
@@ -1249 +1267 @@
     if (err < 0) {
         print_ffmpeg_err(err);
-        return PJ_EUNKNOWN;
+        return PJMEDIA_CODEC_EFAILED;
     } else {
         output->size = err;
@@ -1301 +1319 @@
 
     output->bit_info = 0;
+    output->timestamp = input->timestamp;
 
 #if LIBAVCODEC_VERSION_MAJOR >= 52 && LIBAVCODEC_VERSION_MINOR >= 72
@@ -1316 +1335 @@
 #endif
     if (err < 0) {
+        output->type = PJMEDIA_FRAME_TYPE_NONE;
+        output->size = 0;
         print_ffmpeg_err(err);
-        return PJ_EUNKNOWN;
+        return PJMEDIA_CODEC_EFAILED;
     } else if (got_picture) {
         pjmedia_video_apply_fmt_param *vafp = &ff->dec_vafp;
@@ -1347 +1368 @@
             ff->dec_vfi = pjmedia_get_video_format_info(NULL, ff->param.dec_fmt.id);
             if (!ff->dec_vfi)
-                return PJ_EUNKNOWN;
+                return PJ_ENOTSUP;
             pj_bzero(&ff->dec_vafp, sizeof(ff->dec_vafp));
             ff->dec_vafp.size = ff->param.dec_fmt.det.vid.size;
@@ -1385 +1406 @@
         }
 
+        output->type = PJMEDIA_FRAME_TYPE_VIDEO;
         output->size = vafp->framebytes;
     } else {
-        return PJ_EUNKNOWN;
-    }
-
+        output->type = PJMEDIA_FRAME_TYPE_NONE;
+        output->size = 0;
+    }
+    
     return PJ_SUCCESS;
 }

pjproject/branches/projects/2.0-dev/pjmedia/src/pjmedia/endpoint.c

@@ -546 +546 @@
     pj_status_t status;
 
+    PJ_UNUSED_ARG(options);
+
     /* Make sure video codec manager is instantiated */
     if (!pjmedia_vid_codec_mgr_instance())
@@ -584 +586 @@
         }
 
-        /* Payload type */
-        if (codec_info[i].pt == 255) {
-            PJ_TODO(ALLOCATE_DYNAMIC_PAYLOAD_TYPE);
+        /* Must support RTP packetization and bidirectional */
+        if (!codec_info[i].has_rtp_pack ||
+            codec_info[i].dir != PJMEDIA_DIR_ENCODING_DECODING)
+        {
             continue;
         }

pjproject/branches/projects/2.0-dev/pjmedia/src/pjmedia/ffmpeg_util.c

@@ -55 +55 @@
     {PJMEDIA_FORMAT_H263,       CODEC_ID_H263},
     {PJMEDIA_FORMAT_H263P,      CODEC_ID_H263P},
+    {PJMEDIA_FORMAT_H264,       CODEC_ID_H264},
     {PJMEDIA_FORMAT_MPEG1VIDEO, CODEC_ID_MPEG1VIDEO},
     {PJMEDIA_FORMAT_MPEG2VIDEO, CODEC_ID_MPEG2VIDEO},

pjproject/branches/projects/2.0-dev/pjmedia/src/pjmedia/vid_stream.c

@@ -55 +55 @@
 #endif
 
+#ifndef PJMEDIA_VSTREAM_SIZE
+#   define PJMEDIA_VSTREAM_SIZE 1000
+#endif
+
+#ifndef PJMEDIA_VSTREAM_INC
+#   define PJMEDIA_VSTREAM_INC  1000
+#endif
 
 
@@ -83 +90 @@
 struct pjmedia_vid_stream
 {
+    pj_pool_t               *own_pool;      /**< Internal pool.             */
     pjmedia_endpt           *endpt;         /**< Media endpoint.            */
     pjmedia_vid_codec_mgr   *codec_mgr;     /**< Codec manager.             */
@@ -766 +774 @@
 
     while (processed < frame_out.size) {
-        pj_uint8_t *payload, *rtp_pkt;
+        pj_uint8_t *payload;
+        pj_uint8_t *rtp_pkt;
         pj_size_t payload_len;
 
@@ -775 +784 @@
                                            frame_out.size,
                                            &processed,
-                                           &payload, &payload_len);
+                                           (const pj_uint8_t**)&payload,
+                                           &payload_len);
         if (status != PJ_SUCCESS) {
             LOGERR_((channel->port.info.name.ptr, 
@@ -843 +853 @@
     pjmedia_vid_channel *channel = stream->dec;
     pjmedia_frame frame_in;
-    pj_bool_t fps_changed = PJ_FALSE;
-    pjmedia_ratio new_fps = {0};
+    pj_uint32_t last_ts = 0;
+    int frm_first_seq = 0, frm_last_seq = 0;
     pj_status_t status;
 
@@ -860 +870 @@
         char ptype;
         pj_size_t psize, data_len;
-        pj_uint32_t ts, last_ts;
+        pj_uint32_t ts;
         int seq;
-        pj_bool_t got_frame, check_fps;
+        pj_bool_t got_frame;
         unsigned i;
 
         channel->buf_len = 0;
-        last_ts = 0;
         got_frame = PJ_FALSE;
-        check_fps = PJ_FALSE;
 
         /* Lock jitter buffer mutex first */
@@ -875 +883 @@
         for (i=0; ; ++i) {
             /* Get frame from jitter buffer. */
-            pjmedia_jbuf_peek_frame(stream->jb, i, &p, &psize, &ptype,
-                                    NULL, &ts, &seq);
+            pjmedia_jbuf_peek_frame(stream->jb, i, (const void**)&p,
+                                    &psize, &ptype, NULL, &ts, &seq);
             if (ptype == PJMEDIA_JB_NORMAL_FRAME) {
                 if (last_ts == 0) {
                     last_ts = ts;
-                    check_fps = stream->last_dec_ts &&
-                                (seq - stream->last_dec_seq == 1) &&
-                                (last_ts > stream->last_dec_ts);
+                    frm_first_seq = seq;
                 }
 
@@ -897 +903 @@
                                                            data, &data_len);
                 channel->buf_len += data_len;
+                frm_last_seq = seq;
             } else if (ptype == PJMEDIA_JB_ZERO_EMPTY_FRAME) {
                 /* No more packet in the jitter buffer */
@@ -911 +918 @@
             return PJ_SUCCESS;
         }
-
-        /* Learn remote frame rate */
-        if (check_fps) {
-            pj_uint32_t ts_diff;
-            pjmedia_video_format_detail *vfd;
-
-            ts_diff = last_ts - stream->last_dec_ts;
-            vfd = pjmedia_format_get_video_format_detail(
-                                    &channel->port.info.fmt, PJ_TRUE);
-            if (ts_diff * vfd->fps.num !=
-                stream->info.codec_info.clock_rate * vfd->fps.denum)
-            {
-                /* Frame rate changed */
-                fps_changed = PJ_TRUE;
-                new_fps.num = stream->info.codec_info.clock_rate;
-                new_fps.denum = ts_diff;
-            }
-        }
-
-        /* Update last frame seq and timestamp */
-        stream->last_dec_seq = seq - 1;
-        stream->last_dec_ts = last_ts;
     }
 
@@ -940 +925 @@
     frame_in.bit_info = 0;
     frame_in.type = PJMEDIA_FRAME_TYPE_VIDEO;
+    frame_in.timestamp.u64 = last_ts;
 
     status = stream->codec->op->decode(stream->codec, &frame_in,
@@ -960 +946 @@
     }
 
-    if (fps_changed) {
-        pjmedia_video_format_detail *vfd;
-
-        /* Update decoding channel port info */
-        vfd = pjmedia_format_get_video_format_detail(
-                                &channel->port.info.fmt, PJ_TRUE);
-        vfd->fps = new_fps;
-
-        /* Update stream info */
-        vfd = pjmedia_format_get_video_format_detail(
-                                &stream->info.codec_param->dec_fmt, PJ_TRUE);
-        vfd->fps = new_fps;
-
-        /* Set bit_info */
-        frame->bit_info |= PJMEDIA_VID_CODEC_EVENT_FMT_CHANGED;
-
-        PJ_LOG(4, (channel->port.info.name.ptr, "Frame rate changed to %.2ffps",
-                   (1.0 * new_fps.num / new_fps.denum)));
-    }
+    /* Learn remote frame rate after successful decoding */
+    if (0 && frame->type == PJMEDIA_FRAME_TYPE_VIDEO && frame->size)
+    {
+        /* Only check remote frame rate when timestamp is not wrapping and
+         * sequence is increased by 1.
+         */
+        if (last_ts > stream->last_dec_ts &&
+            frm_first_seq - stream->last_dec_seq == 1)
+        {
+            pj_uint32_t ts_diff;
+            pjmedia_video_format_detail *vfd;
+
+            ts_diff = last_ts - stream->last_dec_ts;
+            vfd = pjmedia_format_get_video_format_detail(
+                                    &channel->port.info.fmt, PJ_TRUE);
+            if ((int)(stream->info.codec_info.clock_rate / ts_diff) !=
+                vfd->fps.num / vfd->fps.denum)
+            {
+                /* Frame rate changed, update decoding port info */
+                vfd->fps.num = stream->info.codec_info.clock_rate;
+                vfd->fps.denum = ts_diff;
+
+                /* Update stream info */
+                stream->info.codec_param->dec_fmt.det.vid.fps = vfd->fps;
+
+                /* Set bit_info */
+                frame->bit_info |= PJMEDIA_VID_CODEC_EVENT_FMT_CHANGED;
+
+                PJ_LOG(5, (channel->port.info.name.ptr, "Frame rate changed to %.2ffps",
+                           (1.0 * vfd->fps.num / vfd->fps.denum)));
+            }
+        }
+
+        /* Update last frame seq and timestamp */
+        stream->last_dec_seq = frm_last_seq;
+        stream->last_dec_ts = last_ts;
+    }
+
+#if PJ_LOG_MAX_LEVEL >= 5
+    if (frame->bit_info & PJMEDIA_VID_CODEC_EVENT_FMT_CHANGED) {
+        pjmedia_port_info *pi = &channel->port.info;
+
+        PJ_LOG(5, (channel->port.info.name.ptr,
+                   "Decoding format changed to %dx%d %c%c%c%c %.2ffps",
+                   pi->fmt.det.vid.size.w, pi->fmt.det.vid.size.h,
+                   ((pi->fmt.id & 0x000000FF) >> 0),
+                   ((pi->fmt.id & 0x0000FF00) >> 8),
+                   ((pi->fmt.id & 0x00FF0000) >> 16),
+                   ((pi->fmt.id & 0xFF000000) >> 24),
+                   (1.0*pi->fmt.det.vid.fps.num/pi->fmt.det.vid.fps.denum)));
+    }
+#endif
 
     return PJ_SUCCESS;
@@ -1001 +1020 @@
     const char *type_name;
     pjmedia_format *fmt;
+    pjmedia_port_info *pi;
     
     pj_assert(info->type == PJMEDIA_TYPE_VIDEO);
@@ -1017 +1037 @@
         fmt = &info->codec_param->enc_fmt;
     }
-
     name.ptr = (char*) pj_pool_alloc(pool, M);
     name.slen = pj_ansi_snprintf(name.ptr, M, "%s%p", type_name, stream);
+    pi = &channel->port.info;
 
     /* Init channel info. */
@@ -1059 +1079 @@
 
     /* Init port. */
-    pjmedia_port_info_init2(&channel->port.info, &name,
+    pjmedia_port_info_init2(pi, &name,
                             PJMEDIA_PORT_SIGNATURE('V', 'C', 'H', 'N'),
                             dir, fmt);
@@ -1065 +1085 @@
         channel->port.get_frame = &get_frame;
     } else {
+        pi->fmt.id = info->codec_param->dec_fmt.id;
         channel->port.put_frame = &put_frame;
     }
@@ -1070 +1091 @@
     /* Init port. */
     channel->port.port_data.pdata = stream;
+
+    PJ_LOG(5, (name.ptr, "%s channel created %dx%d %c%c%c%c%s%.*s %.2ffps",
+               (dir==PJMEDIA_DIR_ENCODING?"Encoding":"Decoding"),
+               pi->fmt.det.vid.size.w, pi->fmt.det.vid.size.h,
+               ((pi->fmt.id & 0x000000FF) >> 0),
+               ((pi->fmt.id & 0x0000FF00) >> 8),
+               ((pi->fmt.id & 0x00FF0000) >> 16),
+               ((pi->fmt.id & 0xFF000000) >> 24),
+               (dir==PJMEDIA_DIR_ENCODING?"->":"<-"),
+               info->codec_info.encoding_name.slen,
+               info->codec_info.encoding_name.ptr,
+               (1.0*pi->fmt.det.vid.fps.num/pi->fmt.det.vid.fps.denum)));
 
     /* Done. */
@@ -1083 +1116 @@
                                         pjmedia_endpt *endpt,
                                         pj_pool_t *pool,
-                                        const pjmedia_vid_stream_info *info,
+                                        pjmedia_vid_stream_info *info,
                                         pjmedia_transport *tp,
                                         void *user_data,
@@ -1089 +1122 @@
 {
     enum { M = 32 };
+    pj_pool_t *own_pool = NULL;
     pjmedia_vid_stream *stream;
     unsigned jb_init, jb_max, jb_min_pre, jb_max_pre, len;
@@ -1096 +1130 @@
     pj_status_t status;
 
+    if (!pool) {
+        own_pool = pjmedia_endpt_create_pool( endpt, "vstrm%p",
+                                              PJMEDIA_VSTREAM_SIZE,
+                                              PJMEDIA_VSTREAM_INC);
+        PJ_ASSERT_RETURN(own_pool != NULL, PJ_ENOMEM);
+        pool = own_pool;
+    }
+
     /* Allocate stream */
     stream = PJ_POOL_ZALLOC_T(pool, pjmedia_vid_stream);
     PJ_ASSERT_RETURN(stream != NULL, PJ_ENOMEM);
-
-    /* Copy stream info */
-    pj_memcpy(&stream->info, info, sizeof(*info));
+    stream->own_pool = own_pool;
 
     /* Get codec manager */
@@ -1121 +1161 @@
 
     /* Get codec param: */
-    if (info->codec_param) {
-        stream->info.codec_param = pjmedia_vid_codec_param_clone(
-                                                        pool,
-                                                        info->codec_param);
-    } else {
+    if (!info->codec_param) {
         pjmedia_vid_codec_param def_param;
 
@@ -1133 +1169 @@
         if (status != PJ_SUCCESS)
             return status;
-        stream->info.codec_param = pjmedia_vid_codec_param_clone(
-                                                        pool,
-                                                        &def_param);
-        pj_assert(stream->info.codec_param);
+
+        info->codec_param = pjmedia_vid_codec_param_clone(pool, &def_param);
+        pj_assert(info->codec_param);
     }
 
     vfd_enc = pjmedia_format_get_video_format_detail(
-                                        &stream->info.codec_param->enc_fmt,
-                                        PJ_TRUE);
+                                        &info->codec_param->enc_fmt, PJ_TRUE);
 
     /* Init stream: */
@@ -1174 +1208 @@
 
     /* Init codec param */
-    stream->info.codec_param->dir = info->dir;
-    stream->info.codec_param->enc_mtu = PJMEDIA_MAX_MTU - 
-                                        sizeof(pjmedia_rtp_hdr);
+    info->codec_param->dir = info->dir;
+    info->codec_param->enc_mtu = PJMEDIA_MAX_MTU - sizeof(pjmedia_rtp_hdr);
 
     /* Init and open the codec. */
@@ -1182 +1215 @@
     if (status != PJ_SUCCESS)
         return status;
-    status = stream->codec->op->open(stream->codec, stream->info.codec_param);
+    status = stream->codec->op->open(stream->codec, info->codec_param);
     if (status != PJ_SUCCESS)
         return status;
@@ -1331 +1364 @@
 #endif
 
+    /* Save the stream info */
+    pj_memcpy(&stream->info, info, sizeof(*info));
+    stream->info.codec_param = pjmedia_vid_codec_param_clone(
+                                                pool, info->codec_param);
+
     /* Success! */
     *p_stream = stream;
 
-    PJ_LOG(5,(THIS_FILE, "Stream %s created", stream->name.ptr));
+    PJ_LOG(5,(THIS_FILE, "Video stream %s created", stream->name.ptr));
 
     return PJ_SUCCESS;
@@ -1435 +1473 @@
 #endif
 
+    if (stream->own_pool) {
+        pj_pool_t *pool = stream->own_pool;
+        stream->own_pool = NULL;
+        pj_pool_release(pool);
+    }
+
     return PJ_SUCCESS;
 }
-