Changeset 3420

Timestamp:

Feb 24, 2011 7:47:55 AM (14 years ago)

Author:

nanang

Message:

Re #1182:

• Added video stream interface in vid_stream.h, the video stream will be able to handle different video formats in encoding and decoding direction.
• Renamed video device stream class identifiers from 'pjmedia_vid_stream*' to 'pjmedia_vid_dev_stream*' as 'pjmedia_vid_stream' is used by video stream interface.
• Added ffmpeg video capability to be able to parse SDP format param for H263 and also decide video format for encoding direction based on remote preference and local format-capability setting.
• Added some new APIs in jitter buffer for handling video stream: pjmedia_jbuf_put_frame3(), pjmedia_jbuf_get_frame3(), pjmedia_jbuf_peek_frame(), and pjmedia_jbuf_remove_frame().
• Moved pjmedia_stream_info_from_sdp() from session to stream

Location:

pjproject/branches/projects/2.0-dev/pjmedia

Files:

• build/pjmedia.vcproj (modified) (10 diffs)
• include/pjmedia-videodev/videodev.h (modified) (12 diffs)
• include/pjmedia-videodev/videodev_imp.h (modified) (5 diffs)
• include/pjmedia.h (modified) (3 diffs)
• include/pjmedia/config.h (modified) (1 diff)
• include/pjmedia/jbuf.h (modified) (5 diffs)
• include/pjmedia/stream.h (modified) (1 diff)
• include/pjmedia/vid_codec.h (modified) (31 diffs)
• include/pjmedia/vid_stream.h (added)
• include/pjmedia/videoport.h (modified) (1 diff)
• src/pjmedia-codec/ffmpeg_codecs.c (modified) (36 diffs)
• src/pjmedia-videodev/colorbar_dev.c (modified) (11 diffs)
• src/pjmedia-videodev/dshow_dev.c (modified) (12 diffs)
• src/pjmedia-videodev/ffmpeg_dev.c (modified) (18 diffs)
• src/pjmedia-videodev/sdl_dev.c (modified) (13 diffs)
• src/pjmedia-videodev/videodev.c (modified) (11 diffs)
• src/pjmedia/jbuf.c (modified) (16 diffs)
• src/pjmedia/stream.c (modified) (2 diffs)
• src/pjmedia/vid_codec.c (modified) (3 diffs)
• src/pjmedia/vid_stream.c (added)
• src/pjmedia/videoport.c (modified) (15 diffs)

pjproject/branches/projects/2.0-dev/pjmedia/build/pjmedia.vcproj

@@ -4313 +4313 @@
                         </File>
                         <File
-                                RelativePath="..\src\pjmedia\session.c"
+                                RelativePath="..\src\pjmedia\silencedet.c"
                                 >
                                 <FileConfiguration
@@ -4371 +4371 @@
                         </File>
                         <File
-                                RelativePath="..\src\pjmedia\silencedet.c"
+                                RelativePath="..\src\pjmedia\sound_legacy.c"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\src\pjmedia\sound_port.c"
                                 >
                                 <FileConfiguration
@@ -4429 +4433 @@
                         </File>
                         <File
-                                RelativePath="..\src\pjmedia\sound_legacy.c"
-                                >
-                        </File>
-                        <File
-                                RelativePath="..\src\pjmedia\sound_port.c"
+                                RelativePath="..\src\pjmedia\splitcomb.c"
                                 >
                                 <FileConfiguration
@@ -4491 +4491 @@
                         </File>
                         <File
-                                RelativePath="..\src\pjmedia\splitcomb.c"
+                                RelativePath="..\src\pjmedia\stereo_port.c"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\src\pjmedia\stream.c"
                                 >
                                 <FileConfiguration
@@ -4549 +4553 @@
                         </File>
                         <File
-                                RelativePath="..\src\pjmedia\stereo_port.c"
-                                >
-                        </File>
-                        <File
-                                RelativePath="..\src\pjmedia\stream.c"
+                                RelativePath="..\src\pjmedia\stream_common.c"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\src\pjmedia\tonegen.c"
                                 >
                                 <FileConfiguration
@@ -4611 +4615 @@
                         </File>
                         <File
-                                RelativePath="..\src\pjmedia\tonegen.c"
+                                RelativePath="..\src\pjmedia\transport_adapter_sample.c"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\src\pjmedia\transport_ice.c"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\src\pjmedia\transport_loop.c"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\src\pjmedia\transport_srtp.c"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\src\pjmedia\transport_udp.c"
                                 >
                                 <FileConfiguration
@@ -4669 +4689 @@
                         </File>
                         <File
-                                RelativePath="..\src\pjmedia\transport_adapter_sample.c"
-                                >
-                        </File>
-                        <File
-                                RelativePath="..\src\pjmedia\transport_ice.c"
-                                >
-                        </File>
-                        <File
-                                RelativePath="..\src\pjmedia\transport_loop.c"
-                                >
-                        </File>
-                        <File
-                                RelativePath="..\src\pjmedia\transport_srtp.c"
-                                >
-                        </File>
-                        <File
-                                RelativePath="..\src\pjmedia\transport_udp.c"
-                                >
-                                <FileConfiguration
-                                        Name="Release|Win32"
-                                        >
-                                        <Tool
-                                                Name="VCCLCompilerTool"
-                                                AdditionalIncludeDirectories=""
-                                                PreprocessorDefinitions=""
-                                        />
-                                </FileConfiguration>
-                                <FileConfiguration
-                                        Name="Debug|Win32"
-                                        >
-                                        <Tool
-                                                Name="VCCLCompilerTool"
-                                                AdditionalIncludeDirectories=""
-                                                PreprocessorDefinitions=""
-                                        />
-                                </FileConfiguration>
-                                <FileConfiguration
-                                        Name="Debug-Static|Win32"
-                                        >
-                                        <Tool
-                                                Name="VCCLCompilerTool"
-                                                AdditionalIncludeDirectories=""
-                                                PreprocessorDefinitions=""
-                                        />
-                                </FileConfiguration>
-                                <FileConfiguration
-                                        Name="Release-Dynamic|Win32"
-                                        >
-                                        <Tool
-                                                Name="VCCLCompilerTool"
-                                                AdditionalIncludeDirectories=""
-                                                PreprocessorDefinitions=""
-                                        />
-                                </FileConfiguration>
-                                <FileConfiguration
-                                        Name="Debug-Dynamic|Win32"
-                                        >
-                                        <Tool
-                                                Name="VCCLCompilerTool"
-                                                AdditionalIncludeDirectories=""
-                                                PreprocessorDefinitions=""
-                                        />
-                                </FileConfiguration>
-                                <FileConfiguration
-                                        Name="Release-Static|Win32"
-                                        >
-                                        <Tool
-                                                Name="VCCLCompilerTool"
-                                                AdditionalIncludeDirectories=""
-                                                PreprocessorDefinitions=""
-                                        />
-                                </FileConfiguration>
-                        </File>
-                        <File
                                 RelativePath="..\src\pjmedia\vid_codec.c"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\src\pjmedia\vid_stream.c"
                                 >
                         </File>
@@ -5120 +5070 @@
                         </File>
                         <File
-                                RelativePath="..\include\pjmedia\session.h"
-                                >
-                        </File>
-                        <File
                                 RelativePath="..\include\pjmedia\silencedet.h"
                                 >
@@ -5148 +5094 @@
                         </File>
                         <File
+                                RelativePath="..\include\pjmedia\stream_common.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\include\pjmedia\tonegen.h"
                                 >
@@ -5181 +5131 @@
                         <File
                                 RelativePath="..\include\pjmedia\vid_codec.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\include\pjmedia\vid_stream.h"
                                 >
                         </File>

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

@@ -79 +79 @@
  *
  * Once video stream is running, application can also retrieve or set some
- * specific video capability, by using #pjmedia_vid_stream_get_cap() and
- * #pjmedia_vid_stream_set_cap() and specifying the desired capability. The
+ * specific video capability, by using #pjmedia_vid_dev_stream_get_cap() and
+ * #pjmedia_vid_dev_stream_set_cap() and specifying the desired capability. The
  * value of the capability is specified as pointer, and application needs to
  * supply the pointer with the correct value, according to the documentation
@@ -155 +155 @@
 
 
-/** Forward declaration for pjmedia_vid_stream */
-typedef struct pjmedia_vid_stream pjmedia_vid_stream;
+/** Forward declaration for pjmedia_vid_dev_stream */
+typedef struct pjmedia_vid_dev_stream pjmedia_vid_dev_stream;
 
 typedef enum pjmedia_event_type
@@ -188 +188 @@
     *                      stream to stop
     */
-    pj_status_t (*capture_cb)(pjmedia_vid_stream *stream,
+    pj_status_t (*capture_cb)(pjmedia_vid_dev_stream *stream,
                               void *user_data,
                               pjmedia_frame *frame);
@@ -211 +211 @@
     *                      stream to stop
     */
-    pj_status_t (*render_cb)(pjmedia_vid_stream *stream,
+    pj_status_t (*render_cb)(pjmedia_vid_dev_stream *stream,
                              void *user_data,
                              pjmedia_frame *frame);
@@ -227 +227 @@
     *                      video stream will ignore the particular event.
     */
-    pj_status_t (*on_event_cb)(pjmedia_vid_stream *stream,
+    pj_status_t (*on_event_cb)(pjmedia_vid_dev_stream *stream,
                                void *user_data,
                                pjmedia_vid_event *event);
@@ -477 +477 @@
  *                      error code.
  */
-PJ_DECL(pj_status_t) pjmedia_vid_stream_create(const pjmedia_vid_param *param,
-                                               const pjmedia_vid_cb *cb,
-                                               void *user_data,
-                                               pjmedia_vid_stream **p_strm);
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_create(
+                                            const pjmedia_vid_param *param,
+                                            const pjmedia_vid_cb *cb,
+                                            void *user_data,
+                                            pjmedia_vid_dev_stream **p_strm);
 
 /**
@@ -492 +493 @@
  *                  error code.
  */
-PJ_DECL(pj_status_t) pjmedia_vid_stream_get_param(pjmedia_vid_stream *strm,
-                                                  pjmedia_vid_param *param);
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_get_param(
+                                            pjmedia_vid_dev_stream *strm,
+                                            pjmedia_vid_param *param);
 
 /**
@@ -508 +510 @@
  *                  error code.
  */
-PJ_DECL(pj_status_t) pjmedia_vid_stream_get_cap(pjmedia_vid_stream *strm,
-                                                pjmedia_vid_dev_cap cap,
-                                                void *value);
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_get_cap(
+                                            pjmedia_vid_dev_stream *strm,
+                                            pjmedia_vid_dev_cap cap,
+                                            void *value);
 
 /**
@@ -523 +526 @@
  *                  error code.
  */
-PJ_DECL(pj_status_t) pjmedia_vid_stream_set_cap(pjmedia_vid_stream *strm,
-                                                pjmedia_vid_dev_cap cap,
-                                                const void *value);
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_set_cap(
+                                            pjmedia_vid_dev_stream *strm,
+                                            pjmedia_vid_dev_cap cap,
+                                            const void *value);
 
 /**
@@ -535 +539 @@
  *                  error code.
  */
-PJ_DECL(pj_status_t) pjmedia_vid_stream_start(pjmedia_vid_stream *strm);
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_start(
+                                            pjmedia_vid_dev_stream *strm);
 
 /* Get/put frame API for passive stream */
-PJ_DECL(pj_status_t) pjmedia_vid_stream_get_frame(pjmedia_vid_stream *strm,
-                                                  pjmedia_frame *frame);
-
-PJ_DECL(pj_status_t) pjmedia_vid_stream_put_frame(pjmedia_vid_stream *strm,
-                                                  const pjmedia_frame *frame);
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_get_frame(
+                                            pjmedia_vid_dev_stream *strm,
+                                            pjmedia_frame *frame);
+
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_put_frame(
+                                            pjmedia_vid_dev_stream *strm,
+                                            const pjmedia_frame *frame);
 
 /**
@@ -552 +559 @@
  *                  error code.
  */
-PJ_DECL(pj_status_t) pjmedia_vid_stream_stop(pjmedia_vid_stream *strm);
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_stop(
+                                            pjmedia_vid_dev_stream *strm);
 
 /**
@@ -562 +570 @@
  *                  error code.
  */
-PJ_DECL(pj_status_t) pjmedia_vid_stream_destroy(pjmedia_vid_stream *strm);
+PJ_DECL(pj_status_t) pjmedia_vid_dev_stream_destroy(
+                                            pjmedia_vid_dev_stream *strm);
 
 

pjproject/branches/projects/2.0-dev/pjmedia/include/pjmedia-videodev/videodev_imp.h

@@ -84 +84 @@
     /**
      * Open the video device and create video stream. See
-     * #pjmedia_vid_stream_create()
+     * #pjmedia_vid_dev_stream_create()
      */
     pj_status_t (*create_stream)(pjmedia_vid_dev_factory *f,
@@ -90 +90 @@
                                  const pjmedia_vid_cb *cb,
                                  void *user_data,
-                                 pjmedia_vid_stream **p_vid_strm);
+                                 pjmedia_vid_dev_stream **p_vid_strm);
 
 } pjmedia_vid_dev_factory_op;
@@ -114 +114 @@
  * Video stream operations.
  */
-typedef struct pjmedia_vid_stream_op
+typedef struct pjmedia_vid_dev_stream_op
 {
     /**
-     * See #pjmedia_vid_stream_get_param()
+     * See #pjmedia_vid_dev_stream_get_param()
      */
-    pj_status_t (*get_param)(pjmedia_vid_stream *strm,
+    pj_status_t (*get_param)(pjmedia_vid_dev_stream *strm,
                              pjmedia_vid_param *param);
 
     /**
-     * See #pjmedia_vid_stream_get_cap()
+     * See #pjmedia_vid_dev_stream_get_cap()
      */
-    pj_status_t (*get_cap)(pjmedia_vid_stream *strm,
+    pj_status_t (*get_cap)(pjmedia_vid_dev_stream *strm,
                            pjmedia_vid_dev_cap cap,
                            void *value);
 
     /**
-     * See #pjmedia_vid_stream_set_cap()
+     * See #pjmedia_vid_dev_stream_set_cap()
      */
-    pj_status_t (*set_cap)(pjmedia_vid_stream *strm,
+    pj_status_t (*set_cap)(pjmedia_vid_dev_stream *strm,
                            pjmedia_vid_dev_cap cap,
                            const void *value);
 
     /**
-     * See #pjmedia_vid_stream_start()
+     * See #pjmedia_vid_dev_stream_start()
      */
-    pj_status_t (*start)(pjmedia_vid_stream *strm);
+    pj_status_t (*start)(pjmedia_vid_dev_stream *strm);
 
     /**
-     * See #pjmedia_vid_stream_get_frame()
+     * See #pjmedia_vid_dev_stream_get_frame()
      */
-    pj_status_t (*get_frame)(pjmedia_vid_stream *strm,
+    pj_status_t (*get_frame)(pjmedia_vid_dev_stream *strm,
                              pjmedia_frame *frame);
 
     /**
-     * See #pjmedia_vid_stream_put_frame()
+     * See #pjmedia_vid_dev_stream_put_frame()
      */
-    pj_status_t (*put_frame)(pjmedia_vid_stream *strm,
+    pj_status_t (*put_frame)(pjmedia_vid_dev_stream *strm,
                              const pjmedia_frame *frame);
 
     /**
-     * See #pjmedia_vid_stream_stop().
+     * See #pjmedia_vid_dev_stream_stop().
      */
-    pj_status_t (*stop)(pjmedia_vid_stream *strm);
+    pj_status_t (*stop)(pjmedia_vid_dev_stream *strm);
 
     /**
-     * See #pjmedia_vid_stream_destroy().
+     * See #pjmedia_vid_dev_stream_destroy().
      */
-    pj_status_t (*destroy)(pjmedia_vid_stream *strm);
+    pj_status_t (*destroy)(pjmedia_vid_dev_stream *strm);
 
-} pjmedia_vid_stream_op;
+} pjmedia_vid_dev_stream_op;
 
 
@@ -169 +169 @@
  * This structure describes the video device stream.
  */
-struct pjmedia_vid_stream
+struct pjmedia_vid_dev_stream
 {
     /** Internal data to be initialized by video subsystem */
@@ -178 +178 @@
 
     /** Operations */
-    pjmedia_vid_stream_op *op;
+    pjmedia_vid_dev_stream_op *op;
 };
 

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

@@ -53 +53 @@
 #include <pjmedia/sdp.h>
 #include <pjmedia/sdp_neg.h>
-#include <pjmedia/session.h>
+//#include <pjmedia/session.h>
 #include <pjmedia/silencedet.h>
 #include <pjmedia/sound.h>
@@ -60 +60 @@
 #include <pjmedia/stereo.h>
 #include <pjmedia/stream.h>
+#include <pjmedia/stream_common.h>
 #include <pjmedia/tonegen.h>
 #include <pjmedia/transport.h>
@@ -69 +70 @@
 #include <pjmedia/videoport.h>
 #include <pjmedia/vid_codec.h>
+#include <pjmedia/vid_stream.h>
 #include <pjmedia/wav_playlist.h>
 #include <pjmedia/wav_port.h>

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

@@ -980 +980 @@
 
 /**
+ * Maximum video frame size.
+ * Default: 16kB
+ */
+#ifndef PJMEDIA_MAX_VIDEO_FRAME_SIZE                    
+#  define PJMEDIA_MAX_VIDEO_FRAME_SIZE                  (1<<14)
+#endif
+
+
+/**
  * Specify the maximum duration (in ms) for resynchronization. When a media
  * is late to another media it is supposed to be synchronized to, it is

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

@@ -69 +69 @@
  * This structure describes jitter buffer state.
  */
-struct pjmedia_jb_state
+typedef struct pjmedia_jb_state
 {
     /* Setting */
@@ -90 +90 @@
     unsigned    discard;            /**< Number of discarded frames.        */
     unsigned    empty;              /**< Number of empty on GET events.     */
-};
-
-
-/**
- * @see pjmedia_jb_state
- */
-typedef struct pjmedia_jb_state pjmedia_jb_state;
+} pjmedia_jb_state;
 
 
@@ -181 +175 @@
 
 /**
+ * Enable/disable the jitter buffer drift detection and handling mechanism.
+ * The default behavior is enabled.
+ *
+ * @param jb            The jitter buffer
+ * @param enable        Set to PJ_TRUE to enable or PJ_FALSE to disable.
+ *
+ * @return              PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t) pjmedia_jbuf_enable_discard(pjmedia_jbuf *jb,
+                                                 pj_bool_t enable);
+
+
+/**
  * Destroy jitter buffer instance.
  *
@@ -244 +251 @@
                                        pj_bool_t *discarded);
 
+/**
+ * Put a frame to the jitter buffer. If the frame can be accepted (based
+ * on the sequence number), the jitter buffer will copy the frame and put
+ * it in the appropriate position in the buffer.
+ *
+ * Application MUST manage it's own synchronization when multiple threads
+ * are accessing the jitter buffer at the same time.
+ *
+ * @param jb            The jitter buffer.
+ * @param frame         Pointer to frame buffer to be stored in the jitter
+ *                      buffer.
+ * @param size          The frame size.
+ * @param bit_info      Bit precise info of the frame, e.g: a frame may not 
+ *                      exactly start and end at the octet boundary, so this
+ *                      field may be used for specifying start & end bit offset.
+ * @param frame_seq     The frame sequence number.
+ * @param frame_ts      The frame timestamp.
+ * @param discarded     Flag whether the frame is discarded by jitter buffer.
+ */
+PJ_DECL(void) pjmedia_jbuf_put_frame3( pjmedia_jbuf *jb, 
+                                       const void *frame, 
+                                       pj_size_t size, 
+                                       pj_uint32_t bit_info,
+                                       int frame_seq,
+                                       pj_uint32_t frame_ts,
+                                       pj_bool_t *discarded);
 /**
  * Get a frame from the jitter buffer. The jitter buffer will return the
@@ -294 +327 @@
 
 
+PJ_DECL(void) pjmedia_jbuf_get_frame3(pjmedia_jbuf *jb, 
+                                      void *frame, 
+                                      pj_size_t *size, 
+                                      char *p_frm_type,
+                                      pj_uint32_t *bit_info,
+                                      pj_uint32_t *ts);
+
+PJ_DECL(void) pjmedia_jbuf_peek_frame(pjmedia_jbuf *jb,
+                                      unsigned idx,
+                                      const void **frame, 
+                                      pj_size_t *size, 
+                                      char *p_frm_type,
+                                      pj_uint32_t *bit_info,
+                                      pj_uint32_t *ts);
+
+PJ_DECL(unsigned) pjmedia_jbuf_remove_frame(pjmedia_jbuf *jb, 
+                                            unsigned frame_cnt);
+
+
 /**
  * Get jitter buffer current state/settings.

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

@@ -144 +144 @@
 
 
+/**
+ * This function will initialize the stream info based on information
+ * in both SDP session descriptors for the specified stream index. 
+ * The remaining information will be taken from default codec parameters. 
+ * If socket info array is specified, the socket will be copied to the 
+ * session info as well.
+ *
+ * @param si            Stream info structure to be initialized.
+ * @param pool          Pool to allocate memory.
+ * @param endpt         PJMEDIA endpoint instance.
+ * @param local         Local SDP session descriptor.
+ * @param remote        Remote SDP session descriptor.
+ * @param stream_idx    Media stream index in the session descriptor.
+ *
+ * @return              PJ_SUCCESS if stream info is successfully initialized.
+ */
+PJ_DECL(pj_status_t)
+pjmedia_stream_info_from_sdp( pjmedia_stream_info *si,
+                              pj_pool_t *pool,
+                              pjmedia_endpt *endpt,
+                              const pjmedia_sdp_session *local,
+                              const pjmedia_sdp_session *remote,
+                              unsigned stream_idx);
+
 
 /**

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

@@ -23 +23 @@
 
 /**
- * @file codec.h
- * @brief Codec framework.
+ * @file vid_codec.h
+ * @brief Video codec framework.
  */
 
@@ -46 +46 @@
     pjmedia_format_id   fmt_id;         /**< Encoded format ID              */
     pj_str_t            encoding_name;  /**< Encoding name                  */
+    unsigned            pt;             /**< Payload type (may be 255 for
+                                             dynamic payload type)          */
+    unsigned            clock_rate;     /**< Clock rate                     */
     pjmedia_dir         dir;            /**< Direction                      */
-    unsigned            pt;             /**< Payload type (may be 0 for
-                                             dynamic payload type)          */
-    unsigned            clock_rate;     /**< (?) Clock rate                 */
-    unsigned            dec_fmt_id_cnt;
+    unsigned            dec_fmt_id_cnt; /**< # of supported encoding source 
+                                             format IDs                     */
     pjmedia_format_id   dec_fmt_id[PJMEDIA_VID_CODEC_MAX_DEC_FMT_CNT];
                                         /**< Supported encoding source 
                                              format IDs                     */
-    unsigned            fps_cnt;        /**< zero if support any fps        */
-    pjmedia_ratio       fps[PJMEDIA_VID_CODEC_MAX_FPS_CNT];    
-                                        /**< (?) supported FPSes, 
-                                             ffmpeg has this                */
+    unsigned            fps_cnt;        /**< # of supported frame-rates, can be
+                                             zero (support any frame-rate)  */
+    pjmedia_ratio       fps[PJMEDIA_VID_CODEC_MAX_FPS_CNT];
+                                        /**< Supported frame-rates          */
 } pjmedia_vid_codec_info;
+
 
 /** 
@@ -80 +82 @@
 
     unsigned            enc_mtu;        /**< MTU or max payload size setting*/
-    unsigned            pt;             /**< Payload type.                  */
 } pjmedia_vid_codec_param;
 
 
-
-/*
- * Forward declaration for pjmedia_vid_codec.
+/**
+ * Enumeration of video codec events.
+ */
+typedef enum pjmedia_vid_codec_event
+{
+    /**
+     * Format changed event. The decoder output format is not really
+     * configurable, so that the output format setting configured in the
+     * initialization may be changed. Application can catch this event
+     * by checking the bit_info field of the pjmedia_frame of the decoder
+     * output frame.
+     */
+    PJMEDIA_VID_CODEC_EVENT_FMT_CHANGED = 1,
+
+} pjmedia_vid_codec_event;
+
+
+/**
+ * Forward declaration for video codec.
  */
 typedef struct pjmedia_vid_codec pjmedia_vid_codec;
@@ -112 +129 @@
      * Open the codec and initialize with the specified parameter.
      * Upon successful initialization, the codec may modify the parameter
-     * and fills in the unspecified values (such as enc_ptime, when
-     * encoder ptime is different than decoder ptime).
+     * and fills in the unspecified values (such as size or frame rate of
+     * the encoder format, as it may need to be negotiated with remote
+     * preferences via SDP fmtp).
      *
      * @param codec     The codec instance.
@@ -139 +157 @@
      * non-PJ_SUCCESS, and the original parameters will not be changed.
      *
-     * Application can expect changing trivial codec settings such as
-     * changing VAD setting to succeed.
-     *
      * @param codec     The codec instance.
      * @param param     The new codec parameter.
@@ -148 +163 @@
      */
     pj_status_t (*modify)(pjmedia_vid_codec *codec, 
-                          const pjmedia_vid_codec_param *param );
+                          const pjmedia_vid_codec_param *param);
+
+    /** 
+     * Get the codec parameter after the codec is opened. 
+     *
+     * @param codec     The codec instance.
+     * @param param     The codec parameter.
+     *
+     * @return          PJ_SUCCESS on success.
+     */
+    pj_status_t (*get_param)(pjmedia_vid_codec *codec,
+                             pjmedia_vid_codec_param *param);
 
     /**
-     * Instruct the codec to inspect the specified payload/packet and
-     * split the packet into individual base frames. Each output frames will
-     * have ptime that is equal to basic frame ptime (i.e. the value of
-     * info.frm_ptime in #pjmedia_vid_codec_param).
+     * Instruct the codec to generate a payload/packet from a picture
+     * bitstream to be sent (via network). The maximum payload size or
+     * MTU is configurable via enc_mtu field of #pjmedia_vid_codec_param.
+     * For a long bitstream, application usually need to call this function
+     * multiple times until the whole bitstream is sent. Note that, for
+     * performance reason, the packetization will be done in-place, so the
+     * original bitstream may be modified by this function.
+     *
+     * @param codec     The codec instance
+     * @param bits      The picture bitstream.
+     * @param bits_len  The length of the bitstream.
+     * @param bits_pos  On input, the start position of the bitstream
+     *                  to be packetized. On output, the next position for
+     *                  next packet.
+     * @param pkt       The pointer of the generated payload.
+     * @param pkt_len   The payload length.
+     *
+     * @return          PJ_SUCCESS on success.
+     */
+    pj_status_t (*packetize) (pjmedia_vid_codec *codec,
+                              pj_uint8_t *bits,
+                              pj_size_t bits_len,
+                              unsigned *bits_pos,
+                              const pj_uint8_t **pkt,
+                              pj_size_t *pkt_len);
+
+    /**
+     * Instruct the codec to parse a payload and append it into a picture
+     * bitstream. A picture bitstreams may need to be reconstructed from
+     * one or more payloads. Note that this function will not provide the
+     * detection of picture boundary, so application should manage the
+     * picture boundary detection by itself, e.g: for RTP delivery, payloads
+     * belong to the same picture will share the same RTP timestamp and also
+     * there is marker bit in the RTP header that is usually reserved for
+     * end-of-picture flag.
      *
      * @param codec     The codec instance
@@ -168 +225 @@
      * @return          PJ_SUCCESS on success.
      */
-    pj_status_t (*packetize) (pjmedia_vid_codec *codec,
-                              pj_uint8_t *buf,
-                              pj_size_t buf_len,
-                              unsigned *pos,
-                              const pj_uint8_t **payload,
-                              pj_size_t *payload_len);
-
-    /**
-     * Instruct the codec to inspect the specified payload/packet and
-     * split the packet into individual base frames. Each output frames will
-     * have ptime that is equal to basic frame ptime (i.e. the value of
-     * info.frm_ptime in #pjmedia_vid_codec_param).
-     *
-     * @param codec     The codec instance
-     * @param pkt       The input packet.
-     * @param pkt_size  Size of the packet.
-     * @param timestamp The timestamp of the first sample in the packet.
-     * @param frame_cnt On input, specifies the maximum number of frames
-     *                  in the array. On output, the codec must fill
-     *                  with number of frames detected in the packet.
-     * @param frames    On output, specifies the frames that have been
-     *                  detected in the packet.
-     *
-     * @return          PJ_SUCCESS on success.
-     */
     pj_status_t (*unpacketize)(pjmedia_vid_codec *codec,
                                const pj_uint8_t *payload,
                                pj_size_t   payload_len,
-                               pj_uint8_t *buf,
-                               pj_size_t  *buf_len);
+                               pj_uint8_t *bits,
+                               pj_size_t  *bits_len);
 
     /** 
      * Instruct the codec to encode the specified input frame. The input
-     * PCM samples MUST have ptime that is multiplication of base frame
-     * ptime (i.e. the value of info.frm_ptime in #pjmedia_vid_codec_param).
+     * MUST contain only one picture with appropriate format as specified
+     * in opening the codec.
      *
      * @param codec     The codec instance.
@@ -218 +250 @@
     /** 
      * Instruct the codec to decode the specified input frame. The input
-     * frame MUST have ptime that is exactly equal to base frame
-     * ptime (i.e. the value of info.frm_ptime in #pjmedia_vid_codec_param).
-     * Application can achieve this by parsing the packet into base
-     * frames before decoding each frame.
+     * frame MUST contain exactly one picture. Note that the decoded picture
+     * format may different to the current setting, e.g: the format specified
+     * in the #pjmedia_vid_codec_param when opening the codec, in this case the
+     * PJMEDIA_VID_CODEC_EVENT_FMT_CHANGED flag will be set in the bit_info
+     * field of the output frame and application can query the new format
+     * using #get_param().
      *
      * @param codec     The codec instance.
@@ -248 +282 @@
                            unsigned out_size,
                            pjmedia_frame *output);
+
 } pjmedia_vid_codec_op;
 
@@ -259 +294 @@
 
 /**
- * This structure describes a codec instance. 
+ * This structure describes a video codec instance. 
  */
 struct pjmedia_vid_codec
@@ -267 +302 @@
 
     /** Codec's private data. */
-    void                    *codec_data;
+    void                        *codec_data;
 
     /** Codec factory where this codec was allocated. */
@@ -273 +308 @@
 
     /** Operations to codec. */
-    pjmedia_vid_codec_op            *op;
+    pjmedia_vid_codec_op        *op;
 };
 
@@ -377 +412 @@
 
 /**
+ * Opaque declaration for codec manager.
+ */
+typedef struct pjmedia_vid_codec_mgr pjmedia_vid_codec_mgr;
+
+/**
  * Declare maximum codecs
  */
@@ -382 +422 @@
 
 
-/** 
- * Codec manager maintains array of these structs for each supported
- * codec.
- */
-typedef struct pjmedia_vid_codec_desc
-{
-    pjmedia_vid_codec_info           info;      /**< Codec info.            */
-    pjmedia_codec_id                 id;        /**< Fully qualified name   */
-    pjmedia_codec_priority           prio;      /**< Priority.              */
-    pjmedia_vid_codec_factory       *factory;   /**< The factory.           */
-    pjmedia_vid_codec_param         *def_param; /**< Default codecs 
-                                                     parameters.            */
-} pjmedia_vid_codec_desc;
-
-
-/**
- * The declaration for codec manager. Application doesn't normally need
- * to see this declaration, but nevertheless this declaration is needed
- * by media endpoint to instantiate the codec manager.
- */
-typedef struct pjmedia_vid_codec_mgr
-{
-    /** Codec manager mutex. */
-    pj_mutex_t                  *mutex;
-
-    /** List of codec factories registered to codec manager. */
-    pjmedia_vid_codec_factory    factory_list;
-
-    /** Number of supported codecs. */
-    unsigned                     codec_cnt;
-
-    /** Array of codec descriptor. */
-    pjmedia_vid_codec_desc       codec_desc[PJMEDIA_CODEC_MGR_MAX_CODECS];
-
-} pjmedia_vid_codec_mgr;
-
-
-
-/**
- * Initialize codec manager. Normally this function is called by pjmedia
+
+/**
+ * Initialize codec manager. If there is no the default video codec manager,
+ * this function will automatically set the default video codec manager to
+ * the new codec manager instance. Normally this function is called by pjmedia
  * endpoint's initialization code.
  *
- * @param mgr       Codec manager instance.
- * @param pf        Pool factory instance.
+ * @param pool      The pool instance.
+ * @param mgr       The pointer to the new codec manager instance.
  *
  * @return          PJ_SUCCESS on success.
@@ -437 +442 @@
  * endpoint's deinitialization code.
  *
- * @param mgr       Codec manager instance.
+ * @param mgr       Codec manager instance.  If NULL, it is the default codec
+ *                  manager instance will be destroyed.
  *
  * @return          PJ_SUCCESS on success.
@@ -443 +449 @@
 PJ_DECL(pj_status_t) pjmedia_vid_codec_mgr_destroy(pjmedia_vid_codec_mgr *mgr);
 
+
+/**
+ * Get the default codec manager instance.
+ *
+ * @return          The default codec manager instance or NULL if none.
+ */
 PJ_DECL(pjmedia_vid_codec_mgr*) pjmedia_vid_codec_mgr_instance(void);
+
+
+/**
+ * Set the default codec manager instance.
+ *
+ * @param mgr       The codec manager instance.
+ */
 PJ_DECL(void) pjmedia_vid_codec_mgr_set_instance(pjmedia_vid_codec_mgr* mgr);
 
@@ -451 +470 @@
  * all supported codecs in the factory to the codec manager.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param factory   The codec factory to be registered.
  *
@@ -466 +485 @@
  * codec manager's list of supported codecs.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param factory   The codec factory to be unregistered.
  *
@@ -480 +499 @@
  * codec manager by codec factories.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param count     On input, specifies the number of elements in
  *                  the array. On output, the value will be set to
@@ -501 +520 @@
  * Get codec info for the specified static payload type.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param pt        Static payload type/number.
- * @param inf       Pointer to receive codec info.
+ * @param info      Pointer to receive codec info.
  *
  * @return          PJ_SUCCESS on success.
@@ -511 +530 @@
 pjmedia_vid_codec_mgr_get_codec_info( pjmedia_vid_codec_mgr *mgr,
                                       unsigned pt,
-                                      const pjmedia_vid_codec_info **inf);
+                                      const pjmedia_vid_codec_info **info);
 
 /**
  * Convert codec info struct into a unique codec identifier.
- * A codec identifier looks something like "L16/44100/2".
+ * A codec identifier looks something like "H263/90000".
  *
  * @param info      The codec info
@@ -532 +551 @@
  * Find codecs by the unique codec identifier. This function will find
  * all codecs that match the codec identifier prefix. For example, if
- * "L16" is specified, then it will find "L16/8000/1", "L16/16000/1",
+ * "H26" is specified, then it will find "H263/90000", "H264/90000",
  * and so on, up to the maximum count specified in the argument.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param codec_id  The full codec ID or codec ID prefix. If an empty
  *                  string is given, it will match all codecs.
@@ -549 +568 @@
  */
 PJ_DECL(pj_status_t) 
-pjmedia_vid_codec_mgr_find_codecs_by_id( pjmedia_vid_codec_mgr *mgr,
-                                     const pj_str_t *codec_id,
-                                     unsigned *count,
-                                     const pjmedia_vid_codec_info *p_info[],
-                                     unsigned prio[]);
+pjmedia_vid_codec_mgr_find_codecs_by_id(pjmedia_vid_codec_mgr *mgr,
+                                        const pj_str_t *codec_id,
+                                        unsigned *count,
+                                        const pjmedia_vid_codec_info *p_info[],
+                                        unsigned prio[]);
 
 
@@ -562 +581 @@
  * priorities of all those codecs.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param codec_id  The full codec ID or codec ID prefix. If an empty
  *                  string is given, it will match all codecs.
@@ -574 +593 @@
 PJ_DECL(pj_status_t)
 pjmedia_vid_codec_mgr_set_codec_priority(pjmedia_vid_codec_mgr *mgr, 
-                                     const pj_str_t *codec_id,
-                                     pj_uint8_t prio);
+                                         const pj_str_t *codec_id,
+                                         pj_uint8_t prio);
 
 
@@ -581 +600 @@
  * Get default codec param for the specified codec info.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param info      The codec info, which default parameter's is being
  *                  queried.
@@ -591 +610 @@
  */
 PJ_DECL(pj_status_t) 
-pjmedia_vid_codec_mgr_get_default_param( pjmedia_vid_codec_mgr *mgr,
-                                     const pjmedia_vid_codec_info *info,
-                                     pjmedia_vid_codec_param *param );
+pjmedia_vid_codec_mgr_get_default_param(pjmedia_vid_codec_mgr *mgr,
+                                        const pjmedia_vid_codec_info *info,
+                                        pjmedia_vid_codec_param *param);
 
 
@@ -599 +618 @@
  * Set default codec param for the specified codec info.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
+ * @param pool      The pool instance.
  * @param info      The codec info, which default parameter's is being
  *                  updated.
@@ -620 +640 @@
  * until it finds factory that is able to create the specified codec.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param info      The information about the codec to be created.
  * @param p_codec   Pointer to receive the codec instance.
@@ -636 +656 @@
  * the instance of the codec back to its factory.
  *
- * @param mgr       The codec manager instance. Application can get the
- *                  instance by calling #pjmedia_endpt_get_codec_mgr().
+ * @param mgr       The codec manager instance. If NULL, the default codec
+ *                  manager instance will be used.
  * @param codec     The codec instance.
  *
@@ -655 +675 @@
 
 /**
- * @defgroup PJMEDIA_CODEC_CODECS Supported codecs
+ * @defgroup PJMEDIA_CODEC_VID_CODECS Supported video codecs
  * @ingroup PJMEDIA_CODEC
- * @brief Documentation about individual codec supported by PJMEDIA
+ * @brief Documentation about individual video codec supported by PJMEDIA
  * @{
  * Please see the APIs provided by the individual codecs below.

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

@@ -109 +109 @@
  * @return              The video stream.
  */
-PJ_DECL(pjmedia_vid_stream*)
+PJ_DECL(pjmedia_vid_dev_stream*)
 pjmedia_vid_port_get_stream(pjmedia_vid_port *vid_port);
 

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

@@ -28 +28 @@
 #include <pj/os.h>
 
+
 /*
  * Only build this file if PJMEDIA_HAS_FFMPEG_CODEC != 0
@@ -38 +39 @@
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
+#include <libswscale/swscale.h>
 
 
@@ -66 +68 @@
 static pj_status_t  ffmpeg_codec_modify(pjmedia_vid_codec *codec, 
                                         const pjmedia_vid_codec_param *attr );
+static pj_status_t  ffmpeg_codec_get_param(pjmedia_vid_codec *codec,
+                                           pjmedia_vid_codec_param *param);
 static pj_status_t  ffmpeg_packetize ( pjmedia_vid_codec *codec,
                                        pj_uint8_t *buf,
@@ -96 +100 @@
     &ffmpeg_codec_close,
     &ffmpeg_codec_modify,
+    &ffmpeg_codec_get_param,
     &ffmpeg_packetize,
     &ffmpeg_unpacketize,
@@ -112 +117 @@
     &ffmpeg_dealloc_codec
 };
-
-
-typedef struct ffmpeg_codec_info {
-    PJ_DECL_LIST_MEMBER(struct ffmpeg_codec_info);
-    pjmedia_vid_codec_info       info;
-    AVCodec                     *enc;
-    AVCodec                     *dec;
-} ffmpeg_codec_info;
 
 
@@ -129 +126 @@
     pj_pool_t                   *pool;
     pj_mutex_t                  *mutex;
-    ffmpeg_codec_info            codecs;
 } ffmpeg_factory;
 
+
+typedef struct ffmpeg_codec_desc ffmpeg_codec_desc;
+
+/* ITU resolution ID */
+typedef enum itu_res_id {
+    ITU_RES_SQCIF,
+    ITU_RES_QCIF,
+    ITU_RES_CIF,
+    ITU_RES_4CIF,
+    ITU_RES_16CIF,
+    ITU_RES_CUSTOM,
+} itu_res_id;
+
+/* ITU resolution definition */
+struct itu_res {
+    itu_res_id          id;
+    pj_str_t            name;    
+    pjmedia_rect_size   size;
+} itu_res_def [] =
+{
+    {ITU_RES_16CIF,     {"16CIF",5},    {1408,1142}},
+    {ITU_RES_4CIF,      {"4CIF",4},     {704,576}},
+    {ITU_RES_CIF,       {"CIF",3},      {352,288}},
+    {ITU_RES_QCIF,      {"QCIF",4},     {176,144}},
+    {ITU_RES_SQCIF,     {"SQCIF",5},    {88,72}},
+    {ITU_RES_CUSTOM,    {"CUSTOM",6},   {0,0}},
+};
 
 /* FFMPEG codecs private data. */
 typedef struct ffmpeg_private {
+    const ffmpeg_codec_desc         *desc;
+    pjmedia_vid_codec_param          param;     /**< Codec param            */
+    pj_pool_t                       *pool;      /**< Pool for each instance */
+    pj_timestamp                     last_tx;   /**< Timestamp of last 
+                                                     transmit               */
+
+    /* Format info and apply format param */
+    const pjmedia_video_format_info *enc_vfi;
+    pjmedia_video_apply_fmt_param    enc_vafp;
+    const pjmedia_video_format_info *dec_vfi;
+    pjmedia_video_apply_fmt_param    dec_vafp;
+
+    /* The ffmpeg codec states. */
+    AVCodec                         *enc;
+    AVCodec                         *dec;
+    AVCodecContext                  *enc_ctx;
+    AVCodecContext                  *dec_ctx;
+
+    /* The ffmpeg decoder cannot set the output format, so format conversion
+     * may be needed for post-decoding.
+     */
+    enum PixelFormat                 expected_dec_fmt;
+                                                /**< expected output format of 
+                                                     ffmpeg decoder         */
+    struct SwsContext               *sws_ctx;   /**< the format converter for 
+                                                     post decoding          */
+
+} ffmpeg_private;
+
+
+typedef pj_status_t (*func_packetize)   (pj_uint8_t *buf,
+                                         pj_size_t buf_len,
+                                         unsigned *pos,
+                                         int max_payload_len,
+                                         const pj_uint8_t **payload,
+                                         pj_size_t *payload_len);
+
+typedef pj_status_t (*func_unpacketize) (const pj_uint8_t *payload,
+                                         pj_size_t   payload_len,
+                                         pj_uint8_t *bits,
+                                         pj_size_t  *bits_len);
+
+typedef pj_status_t (*func_parse_fmtp)  (ffmpeg_private *ff);
+
+/* FFMPEG codec info */
+struct ffmpeg_codec_desc {
+    /* Predefined info */
+    pjmedia_vid_codec_info       info;
+    func_packetize               packetize;
+    func_unpacketize             unpacketize;
+    func_parse_fmtp              parse_fmtp;
+    pjmedia_codec_fmtp           dec_fmtp;
+
+    /* Init time defined info */
+    pj_bool_t                    enabled;
     AVCodec                     *enc;
     AVCodec                     *dec;
-    AVCodecContext              *enc_ctx;
-    AVCodecContext              *dec_ctx;
-    AVCodecParserContext        *dec_parser_ctx;
-
-    /*
-    pjmedia_frame               *pack_frms;
-    unsigned                     pack_frm_cnt;
-    unsigned                     pack_frm_max_cnt;
-    */
-
-    pjmedia_vid_codec_param      param;     /**< Codec param.               */
-    pj_pool_t                   *pool;      /**< Pool for each instance.    */
-    pj_timestamp                 last_tx;   /**< Timestamp of last transmit.*/
-    const pjmedia_video_format_info *vfi;
-    pjmedia_video_apply_fmt_param    vafp;
-} ffmpeg_private;
+};
+
+/* H263 packetizer */
+static pj_status_t h263_packetize(pj_uint8_t *buf,
+                                  pj_size_t buf_len,
+                                  unsigned *pos,
+                                  int max_payload_len,
+                                  const pj_uint8_t **payload,
+                                  pj_size_t *payload_len)
+{
+    return pjmedia_h263_packetize(buf, buf_len, pos, max_payload_len, 
+                                  payload, payload_len);
+}
+
+/* H263 unpacketizer */
+static pj_status_t h263_unpacketize(const pj_uint8_t *payload,
+                                    pj_size_t   payload_len,
+                                    pj_uint8_t *bits,
+                                    pj_size_t  *bits_len)
+{
+    return pjmedia_h263_unpacketize(payload, payload_len, bits, bits_len);
+}
+
+/* H263 fmtp parser */
+static pj_status_t h263_parse_fmtp(ffmpeg_private *ff);
+
+
+/* Internal codec info */
+ffmpeg_codec_desc codec_desc[] =
+{
+    {
+        {PJMEDIA_FORMAT_H263,   {"H263",4},     PJMEDIA_RTP_PT_H263},
+        &h263_packetize, &h263_unpacketize, &h263_parse_fmtp,
+        {2, { {{"CIF",3}, {"2",1}}, {{"QCIF",4}, {"1",1}}, } },
+    },
+    {
+        {PJMEDIA_FORMAT_H261,   {"H261",4},     PJMEDIA_RTP_PT_H261},
+    },
+    {
+        {PJMEDIA_FORMAT_MJPEG,  {"JPEG",4},     PJMEDIA_RTP_PT_JPEG},
+    },
+};
+
+/* Parse fmtp value for custom resolution, e.g: "CUSTOM=800,600,2" */
+static pj_status_t parse_fmtp_itu_custom_res(const pj_str_t *fmtp_val,
+                                             pjmedia_rect_size *size,
+                                             unsigned *mpi)
+{
+    const char *p, *p_end;
+    pj_str_t token;
+    unsigned long val[3] = {0};
+    unsigned i = 0;
+
+    p = token.ptr = fmtp_val->ptr;
+    p_end = p + fmtp_val->slen;
+
+    while (p<=p_end && i<PJ_ARRAY_SIZE(val)) {
+        if (*p==',' || p==p_end) {
+            token.slen = (char*)p - token.ptr;
+            val[i++] = pj_strtoul(&token);
+            token.ptr = (char*)p+1;
+        }
+        ++p;
+    }
+
+    if (!val[0] || !val[1])
+        return PJ_ETOOSMALL;
+
+    if (val[2]<1 || val[2]>32)
+        return PJ_EINVAL;
+
+    size->w = val[0];
+    size->h = val[1];
+    *mpi = val[2];
+    return PJ_SUCCESS;
+}
+
+#define CALC_ITU_CUSTOM_RES_SCORE(size, mpi) ((size)->w * (size)->h / mpi)
+
+/* ITU codec capabilities */
+typedef struct itu_cap
+{
+    /* Lowest MPI for each non-custom resolution */
+    unsigned            lowest_mpi[PJ_ARRAY_SIZE(itu_res_def)];
+    /* For custom resolution, we use maximum processing score */
+    unsigned            custom_res_max_score;
+} itu_cap;
+
+
+static pj_status_t load_itu_cap(const pjmedia_codec_fmtp *fmtp,
+                                itu_cap *cap)
+{
+    unsigned i, j;
+    unsigned min_mpi = 0;
+
+    /* Get Minimum Picture Interval (MPI) for each resolution. If a resolution
+     * has no MPI setting in fmtp, the MPI setting is derived from the higher
+     * resolution.
+     */
+    for (i=0; i<PJ_ARRAY_SIZE(itu_res_def); ++i) {
+
+        /* Init lowest MPI */
+        cap->lowest_mpi[i] = min_mpi? min_mpi:1;
+
+        for (j=0; j<fmtp->cnt; ++j) {
+            if (pj_stricmp(&fmtp->param[j].name, &itu_res_def[i].name)==0) {
+                pjmedia_rect_size size;
+                unsigned mpi;
+                unsigned score;
+
+                if (i != ITU_RES_CUSTOM) {
+                    size = itu_res_def[i].size;
+                    mpi = pj_strtoul(&fmtp->param[j].val);
+                    if (min_mpi)
+                        min_mpi = PJ_MIN(mpi, min_mpi);
+                    else
+                        min_mpi = mpi;
+
+                    /* Update the lowest MPI for this resolution */
+                    cap->lowest_mpi[i] = min_mpi;
+
+                    /* Also update the processing score for the custom 
+                     * resolution.
+                     */
+                    score = CALC_ITU_CUSTOM_RES_SCORE(&size, mpi);
+                    cap->custom_res_max_score = 
+                                    PJ_MAX(score, cap->custom_res_max_score);
+                } else {
+                    
+
+                    if (parse_fmtp_itu_custom_res(&fmtp->param[j].val, 
+                                                  &size, &mpi) == PJ_SUCCESS)
+                    {
+                        score = CALC_ITU_CUSTOM_RES_SCORE(&size, mpi);
+                        cap->custom_res_max_score = 
+                                    PJ_MAX(score, cap->custom_res_max_score);
+                    }
+                }
+            }
+        }
+    }
+
+    return PJ_SUCCESS;
+}
+
+/* H263 fmtp parser */
+static pj_status_t h263_parse_fmtp(ffmpeg_private *ff)
+{
+    pjmedia_dir dir;
+    pj_status_t status;
+
+    dir = ff->param.dir;
+
+    if (ff->param.dir & PJMEDIA_DIR_ENCODING) {
+        pjmedia_vid_codec_param param_ref;
+        pjmedia_codec_fmtp *fmtp_rem, *fmtp_ref;
+        itu_cap local_cap;
+        pjmedia_rect_size size = {0};
+        unsigned mpi = 0;
+        pj_bool_t got_good_res = PJ_FALSE;
+        pj_bool_t has_prefered_res = PJ_FALSE;
+        unsigned i, j;
+
+        fmtp_rem = &ff->param.enc_fmtp;
+        dir &= ~PJMEDIA_DIR_ENCODING;
+
+        /* Get default fmtp setting as the reference for local capabilities */
+        status = pjmedia_vid_codec_mgr_get_default_param(
+                        ffmpeg_factory.mgr, &ff->desc->info, &param_ref);
+        fmtp_ref = (status==PJ_SUCCESS)? &param_ref.enc_fmtp : fmtp_rem;
+
+        /* Load default local capabilities */
+        status = load_itu_cap(fmtp_ref, &local_cap);
+        pj_assert(status == PJ_SUCCESS);
+
+        /* Negotiate resolution and MPI */
+        for (i=0; i<fmtp_rem->cnt && !got_good_res; ++i)
+        {
+            for (j=0; j<PJ_ARRAY_SIZE(itu_res_def) && !got_good_res; ++j)
+            {
+                if (pj_stricmp(&fmtp_rem->param[i].name, &itu_res_def[j].name))
+                    continue;
+
+                has_prefered_res = PJ_TRUE;
+                if (j == ITU_RES_CUSTOM) {
+                    unsigned score;
+
+                    if (parse_fmtp_itu_custom_res(&fmtp_rem->param[i].val, 
+                                                  &size, &mpi) != PJ_SUCCESS)
+                    {
+                        /* Invalid custom resolution format, skip this 
+                         * custom resolution
+                         */
+                        break;
+                    }
+
+                    score = CALC_ITU_CUSTOM_RES_SCORE(&size, mpi);
+                    if (score <= local_cap.custom_res_max_score)
+                        got_good_res = PJ_TRUE;
+                } else {
+                    mpi = pj_strtoul(&fmtp_rem->param[i].val);
+                    if (mpi>=1 && mpi<=32 && mpi>=local_cap.lowest_mpi[j]) {
+                        got_good_res = PJ_TRUE;
+                        size = itu_res_def[j].size;
+                    }
+                }
+            }
+        }
+
+        if (has_prefered_res) {
+            if (got_good_res) {
+                pjmedia_video_format_detail *vfd;
+
+                /* Apply this size & MPI */
+                vfd = pjmedia_format_get_video_format_detail(&ff->param.enc_fmt,
+                                                             PJ_TRUE);
+                vfd->size = size;
+                vfd->fps.num = 30000;
+                vfd->fps.denum = 1001 * mpi;
+                got_good_res = PJ_TRUE;
+
+                PJ_TODO(NOTIFY_APP_ABOUT_THIS_NEW_ENCODING_FORMAT);
+            } else {
+                return PJ_EUNKNOWN;
+            }
+        }
+    }
+
+    return PJ_SUCCESS;
+}
+
+
+
+static const ffmpeg_codec_desc* find_codec_info(
+                        const pjmedia_vid_codec_info *info)
+{
+    int i;
+
+    for (i=0; i<PJ_ARRAY_SIZE(codec_desc); ++i) {
+        ffmpeg_codec_desc *desc = &codec_desc[i];
+
+        if (desc->enabled &&
+            (desc->info.fmt_id == info->fmt_id) &&
+            ((desc->info.dir & info->dir) == info->dir) &&
+            pj_stricmp(&desc->info.encoding_name, &info->encoding_name)==0)
+        {
+            return desc;
+        }
+    }
+
+    return NULL;
+}
+
+
+static int find_codec_info_idx_by_fmt_id(pjmedia_format_id fmt_id)
+{
+    int i;
+    for (i=0; i<PJ_ARRAY_SIZE(codec_desc); ++i) {
+        if (codec_desc[i].info.fmt_id == fmt_id)
+            return i;
+    }
+
+    return -1;
+}
 
 
@@ -163 +489 @@
     pj_pool_t *pool;
     AVCodec *c;
-    enum CodecID last_codec_id = CODEC_ID_NONE;
     pj_status_t status;
 
@@ -179 +504 @@
     ffmpeg_factory.mgr = mgr;
     ffmpeg_factory.pf = pf;
-    pj_list_init(&ffmpeg_factory.codecs);
 
     pool = pj_pool_create(pf, "ffmpeg codec factory", 256, 256, NULL);
@@ -197 +521 @@
     for (c=av_codec_next(NULL); c; c=av_codec_next(c)) 
     {
-        ffmpeg_codec_info *ci;
+        ffmpeg_codec_desc *desc;
+        pjmedia_format_id fmt_id;
+        int codec_info_idx;
         
         if (c->type != CODEC_TYPE_VIDEO)
@@ -203 +529 @@
 
         /* Video encoder and decoder are usually implemented in separate
-         * AVCodec instances.
+         * AVCodec instances. While the codec attributes (e.g: raw formats,
+         * supported fps) are in the encoder.
          */
 
-        if (c->id == last_codec_id) {
-            /* This codec usually be the decoder, and not as much info as in
-             * encoder can be fetched here.
-             */
-            pj_assert(!pj_list_empty(&ffmpeg_factory.codecs));
-            ci = ffmpeg_factory.codecs.prev;
-            pj_assert(ci->info.dir != PJMEDIA_DIR_ENCODING_DECODING);
-            pj_assert(!ci->dec || !ci->enc);
-        } else {
-            pjmedia_format_id enc_fmt_id;
-            pjmedia_format_id raw_fmt[PJMEDIA_VID_CODEC_MAX_DEC_FMT_CNT];
-            unsigned raw_fmt_cnt = 0;
-            unsigned raw_fmt_cnt_should_be = 0;
-
-            /* Get encoded format id */
-            status = CodecID_to_pjmedia_format_id(c->id, &enc_fmt_id);
-            if (status != PJ_SUCCESS) {
-                //PJ_LOG(5, (THIS_FILE, "Unrecognized ffmpeg codec id %d, "
-                //                      "codec [%s/%s] ignored",
-                //                      c->id, c->name, c->long_name));
-                //enc_fmt_id = PJMEDIA_FORMAT_FFMPEG_UNKNOWN;
-
-                /* Skip unrecognized encoding format ID */
-                continue;
-            }
-
-            /* Get raw/decoded format ids */
-            if (c->pix_fmts) {
-                const enum PixelFormat *p = c->pix_fmts;
-                for(;(p && *p != -1) &&
-                     (raw_fmt_cnt < PJMEDIA_VID_CODEC_MAX_DEC_FMT_CNT);
-                     ++p)
-                {
-                    pjmedia_format_id fmt_id;
-
-                    raw_fmt_cnt_should_be++;
-                    status = PixelFormat_to_pjmedia_format_id(*p, &fmt_id);
-                    if (status != PJ_SUCCESS) {
-                        PJ_LOG(6, (THIS_FILE, "Unrecognized ffmpeg pixel "
-                                   "format %d", *p));
-                        continue;
-                    }
-                    raw_fmt[raw_fmt_cnt++] = fmt_id;
-                }
-            } else {
-                /* Unknown raw format, ignore this codec? */
-                continue;
-            }
-
-            if (raw_fmt_cnt < raw_fmt_cnt_should_be) {
-                PJ_LOG(6, (THIS_FILE, "Codec [%s/%s] have %d raw formats, "
-                                      "recognized only %d raw formats",
-                                      c->name, c->long_name,
-                                      raw_fmt_cnt_should_be, raw_fmt_cnt));
-            }
-            if (raw_fmt_cnt == 0) {
-                PJ_LOG(5, (THIS_FILE, "No recognized raw format "
-                                      "for codec [%s/%s], codec ignored",
-                                      c->name, c->long_name));
-                /* Comment this to see all ffmpeg codecs */
-                continue;
-            }
-
-            ci = PJ_POOL_ZALLOC_T(pool, ffmpeg_codec_info);
-            ci->info.fmt_id = enc_fmt_id;
-            pj_cstr(&ci->info.encoding_name, c->name);
-            ci->info.clock_rate = 90000;
-            ci->info.dec_fmt_id_cnt = raw_fmt_cnt;
-            pj_memcpy(ci->info.dec_fmt_id, raw_fmt, 
-                      sizeof(raw_fmt[0])*raw_fmt_cnt);
-
-            switch (enc_fmt_id) {
-                case PJMEDIA_FORMAT_H263:
-                    ci->info.pt = PJMEDIA_RTP_PT_H263;
-                    break;
-                case PJMEDIA_FORMAT_H261:
-                    ci->info.pt = PJMEDIA_RTP_PT_H261;
-                    break;
-                default:
-                    break;
-            }
-
-            if (c->supported_framerates) {
-                const AVRational *fr = c->supported_framerates;
-                while ((fr->num != 0 || fr->den != 0) && 
-                       ci->info.fps_cnt < PJMEDIA_VID_CODEC_MAX_FPS_CNT)
-                {
-                    ci->info.fps[ci->info.fps_cnt].num = fr->num;
-                    ci->info.fps[ci->info.fps_cnt].denum = fr->den;
-                    ++ci->info.fps_cnt;
-                    ++fr;
-                }
-            }
-
-            pj_list_push_back(&ffmpeg_factory.codecs, ci);
+        status = CodecID_to_pjmedia_format_id(c->id, &fmt_id);
+        /* Skip if format ID is unknown */
+        if (status != PJ_SUCCESS)
+            continue;
+
+        codec_info_idx = find_codec_info_idx_by_fmt_id(fmt_id);
+        /* Skip if codec is unwanted by this wrapper (not listed in 
+         * the codec info array)
+         */
+        if (codec_info_idx < 0)
+            continue;
+
+        desc = &codec_desc[codec_info_idx];
+
+        /* Skip duplicated codec implementation */
+        if ((c->encode && (desc->info.dir & PJMEDIA_DIR_ENCODING)) ||
+            (c->decode && (desc->info.dir & PJMEDIA_DIR_DECODING)))
+        {
+            continue;
+        }
+
+        /* Get raw/decoded format ids in the encoder */
+        if (c->pix_fmts && c->encode) {
+            pjmedia_format_id raw_fmt[PJMEDIA_VID_CODEC_MAX_DEC_FMT_CNT];
+            unsigned raw_fmt_cnt = 0;
+            unsigned raw_fmt_cnt_should_be = 0;
+            const enum PixelFormat *p = c->pix_fmts;
+
+            for(;(p && *p != -1) &&
+                 (raw_fmt_cnt < PJMEDIA_VID_CODEC_MAX_DEC_FMT_CNT);
+                 ++p)
+            {
+                pjmedia_format_id fmt_id;
+
+                raw_fmt_cnt_should_be++;
+                status = PixelFormat_to_pjmedia_format_id(*p, &fmt_id);
+                if (status != PJ_SUCCESS) {
+                    PJ_LOG(6, (THIS_FILE, "Unrecognized ffmpeg pixel "
+                               "format %d", *p));
+                    continue;
+                }
+                raw_fmt[raw_fmt_cnt++] = fmt_id;
+            }
+
+            if (raw_fmt_cnt == 0) {
+                PJ_LOG(5, (THIS_FILE, "No recognized raw format "
+                                      "for codec [%s/%s], codec ignored",
+                                      c->name, c->long_name));
+                /* Skip this encoder */
+                continue;
+            }
+
+            if (raw_fmt_cnt < raw_fmt_cnt_should_be) {
+                PJ_LOG(6, (THIS_FILE, "Codec [%s/%s] have %d raw formats, "
+                                      "recognized only %d raw formats",
+                                      c->name, c->long_name,
+                                      raw_fmt_cnt_should_be, raw_fmt_cnt));
+            }
+
+            desc->info.dec_fmt_id_cnt = raw_fmt_cnt;
+            pj_memcpy(desc->info.dec_fmt_id, raw_fmt, 
+                      sizeof(raw_fmt[0])*raw_fmt_cnt);
+        }
+
+        /* Get supported framerates */
+        if (c->supported_framerates) {
+            const AVRational *fr = c->supported_framerates;
+            while ((fr->num != 0 || fr->den != 0) && 
+                   desc->info.fps_cnt < PJMEDIA_VID_CODEC_MAX_FPS_CNT)
+            {
+                desc->info.fps[desc->info.fps_cnt].num = fr->num;
+                desc->info.fps[desc->info.fps_cnt].denum = fr->den;
+                ++desc->info.fps_cnt;
+                ++fr;
+            }
+        }
+
+        /* Get ffmpeg encoder instance */
+        if (c->encode && !desc->enc) {
+            desc->info.dir |= PJMEDIA_DIR_ENCODING;
+            desc->enc = c;
         }
-
-        if (c->encode) {
-            ci->info.dir |= PJMEDIA_DIR_ENCODING;
-            ci->enc = c;
+        
+        /* Get ffmpeg decoder instance */
+        if (c->decode && !desc->dec) {
+            desc->info.dir |= PJMEDIA_DIR_DECODING;
+            desc->dec = c;
         }
-        if (c->decode) {
-            ci->info.dir |= PJMEDIA_DIR_DECODING;
-            ci->dec = c;
-        }
-
-        last_codec_id = c->id;
+
+        /* Enable this codec when any ffmpeg codec instance are recognized
+         * and the supported raw formats info has been collected.
+         */
+        if ((desc->dec || desc->enc) && desc->info.dec_fmt_id_cnt)
+        {
+            desc->enabled = PJ_TRUE;
+        }
+
+        /* Normalize default value of clock rate */
+        if (desc->info.clock_rate == 0)
+            desc->info.clock_rate = 90000;
     }
 
@@ -360 +680 @@
 
 
-static ffmpeg_codec_info* find_codec(const pjmedia_vid_codec_info *info)
-{
-    ffmpeg_codec_info *ci = ffmpeg_factory.codecs.next;
-
-    pj_mutex_lock(ffmpeg_factory.mutex);
-
-    while (ci != &ffmpeg_factory.codecs) {
-        if ((ci->info.fmt_id == info->fmt_id) &&
-            ((ci->info.dir & info->dir) == info->dir) &&
-            pj_stricmp(&ci->info.encoding_name, &info->encoding_name)==0)
-        {
-            pj_mutex_unlock(ffmpeg_factory.mutex);
-            return ci;
-        }
-        ci = ci->next;
-    }
-
-    pj_mutex_unlock(ffmpeg_factory.mutex);
-
-    return NULL;
-}
-
-
 /* 
  * Check if factory can allocate the specified codec. 
@@ -389 +686 @@
                                       const pjmedia_vid_codec_info *info )
 {
-    ffmpeg_codec_info *ci;
+    const ffmpeg_codec_desc *desc;
 
     PJ_ASSERT_RETURN(factory==&ffmpeg_factory.base, PJ_EINVAL);
     PJ_ASSERT_RETURN(info, PJ_EINVAL);
 
-    ci = find_codec(info);
-    if (!ci) {
+    desc = find_codec_info(info);
+    if (!desc) {
         return PJMEDIA_CODEC_EUNSUP;
     }
@@ -409 +706 @@
                                         pjmedia_vid_codec_param *attr )
 {
-    ffmpeg_codec_info *ci;
+    const ffmpeg_codec_desc *desc;
 
     PJ_ASSERT_RETURN(factory==&ffmpeg_factory.base, PJ_EINVAL);
     PJ_ASSERT_RETURN(info && attr, PJ_EINVAL);
 
-    ci = find_codec(info);
-    if (!ci) {
+    desc = find_codec_info(info);
+    if (!desc) {
         return PJMEDIA_CODEC_EUNSUP;
     }
 
     pj_bzero(attr, sizeof(pjmedia_vid_codec_param));
-    attr->dir = ci->info.dir;
-    attr->pt = info->pt;
-    pjmedia_format_init_video(&attr->enc_fmt, ci->info.fmt_id,
-                              352, 288, 25, 1);
-    pjmedia_format_init_video(&attr->dec_fmt, ci->info.dec_fmt_id[0],
-                              352, 288, 25, 1);
+
+    /* Direction */
+    attr->dir = desc->info.dir;
+
+    /* Encoded format */
+    pjmedia_format_init_video(&attr->enc_fmt, desc->info.fmt_id,
+                              352, 288, 30000, 1001);
+
+    /* Decoded format */
+    pjmedia_format_init_video(&attr->dec_fmt, desc->info.dec_fmt_id[0],
+                              352, 288, 30000, 1001);
+
+    /* Decoding fmtp */
+    attr->dec_fmtp = desc->dec_fmtp;
 
     return PJ_SUCCESS;
@@ -437 +742 @@
                                        pjmedia_vid_codec_info codecs[])
 {
-    ffmpeg_codec_info *ci;
-    unsigned max;
+    unsigned i;
 
     PJ_ASSERT_RETURN(codecs && *count > 0, PJ_EINVAL);
     PJ_ASSERT_RETURN(factory == &ffmpeg_factory.base, PJ_EINVAL);
 
-    max = *count;
-    *count = 0;
-    ci = ffmpeg_factory.codecs.next;
-
-    pj_mutex_lock(ffmpeg_factory.mutex);
-    while (*count < max && ci != &ffmpeg_factory.codecs) {
-        pj_memcpy(&codecs[*count], &ci->info, sizeof(pjmedia_vid_codec_info));
-        *count = *count + 1;
-        ci = ci->next;
-    }
-    pj_mutex_unlock(ffmpeg_factory.mutex);
+    *count = PJ_MIN(*count, PJ_ARRAY_SIZE(codec_desc));
+
+    for (i=0; i<*count; ++i) {
+        pj_memcpy(&codecs[i], &codec_desc[i].info, 
+                  sizeof(pjmedia_vid_codec_info));
+    }
 
     return PJ_SUCCESS;
@@ -466 +765 @@
 {
     ffmpeg_private *ff;
-    ffmpeg_codec_info *ci;
+    const ffmpeg_codec_desc *desc;
     pjmedia_vid_codec *codec;
     pj_pool_t *pool = NULL;
@@ -474 +773 @@
     PJ_ASSERT_RETURN(factory == &ffmpeg_factory.base, PJ_EINVAL);
 
-    ci = find_codec(info);
-    if (!ci) {
+    desc = find_codec_info(info);
+    if (!desc) {
         return PJMEDIA_CODEC_EUNSUP;
     }
@@ -495 +794 @@
     codec->codec_data = ff;
     ff->pool = pool;
-    ff->enc = ci->enc;
-    ff->dec = ci->dec;
+    ff->enc = desc->enc;
+    ff->dec = desc->dec;
+    ff->desc = desc;
 
     *p_codec = codec;
@@ -551 +851 @@
 }
 
-/*
-static enum PixelFormat ffdec_nego_format(struct AVCodecContext *s, 
+static enum PixelFormat dec_get_format(struct AVCodecContext *s, 
                                           const enum PixelFormat * fmt)
 {
-    enum PixelFormat pix_fmt;
-
-    PJ_UNUSED_ARG(s);
-    PJ_UNUSED_ARG(fmt);
-
-    pjmedia_format_id_to_PixelFormat(PJMEDIA_FORMAT_BGRA, &pix_fmt);
-    return pix_fmt;
-}
-
-static void enc_got_payload(struct AVCodecContext *avctx,
-                            void *data, int size, int mb_nb);
-*/
+    ffmpeg_private *ff = (ffmpeg_private*)s->opaque;
+    enum PixelFormat def_fmt = *fmt;
+
+    while (*fmt != -1) {
+        if (*fmt == ff->expected_dec_fmt)
+            return *fmt;
+        ++fmt;
+    }
+
+    pj_assert(!"Inconsistency in supported formats");
+    return def_fmt;
+}
 
 
@@ -574 +873 @@
     enum PixelFormat pix_fmt;
     pj_status_t status;
+    pjmedia_video_format_detail *vfd;
 
     status = pjmedia_format_id_to_PixelFormat(ff->param.dec_fmt.id,
@@ -579 +879 @@
     if (status != PJ_SUCCESS)
         return status;
+
+    vfd = pjmedia_format_get_video_format_detail(&ff->param.enc_fmt, 
+                                                 PJ_TRUE);
+    ff->expected_dec_fmt = pix_fmt;
 
     while (((ff->param.dir & PJMEDIA_DIR_ENCODING) && ff->enc_ctx == NULL) ||
@@ -595 +899 @@
         }
 
+        /* Init ffmpeg codec context */
         ctx = avcodec_alloc_context();
 
         /* Common attributes */
         ctx->pix_fmt = pix_fmt;
-        ctx->width = ff->param.enc_fmt.det.vid.size.w;
-        ctx->height = ff->param.enc_fmt.det.vid.size.h;
         ctx->workaround_bugs = FF_BUG_AUTODETECT;
         ctx->opaque = ff;
@@ -608 +911 @@
 
             /* Encoding only attributes */
-            ctx->time_base.num = ff->param.enc_fmt.det.vid.fps.denum;
-            ctx->time_base.den = ff->param.enc_fmt.det.vid.fps.num;
-            if (ff->param.enc_fmt.det.vid.avg_bps)
-                ctx->bit_rate = ff->param.enc_fmt.det.vid.avg_bps;
-            if (ff->param.enc_fmt.det.vid.max_bps)
-                ctx->rc_max_rate = ff->param.enc_fmt.det.vid.max_bps;
-#if 0
-            if (ff->param.enc_mtu) {
-                //ctx->rtp_payload_size = ff->param.enc_mtu;
-                //ctx->rtp_callback = &enc_got_payload;
-
-                /* Allocate frame array for RTP payload packing */
-                if (ff->param.enc_fmt.det.vid.max_bps)
-                    ff->pack_frm_max_cnt = ff->param.enc_fmt.det.vid.max_bps /
-                                           ff->param.enc_mtu + 1;
-                else
-                    ff->pack_frm_max_cnt = 32;
-
-                ff->pack_frms = (pjmedia_frame*)
-                                pj_pool_calloc(ff->pool, ff->pack_frm_max_cnt,
-                                               sizeof(ff->pack_frms[0]));
-            }
-#endif
-
-            /* For encoder, should be better to be strict to the standards */
+            ctx->width = vfd->size.w;
+            ctx->height = vfd->size.h;
+            ctx->time_base.num = vfd->fps.denum;
+            ctx->time_base.den = vfd->fps.num;
+            if (vfd->avg_bps)
+                ctx->bit_rate = vfd->avg_bps;
+            if (vfd->max_bps)
+                ctx->rc_max_rate = vfd->max_bps;
+
+            /* For encoder, should be better to be strict to the standards */
             ctx->strict_std_compliance = FF_COMPLIANCE_STRICT;
         }
+
         if (dir & PJMEDIA_DIR_DECODING) {
             codec = ff->dec;
 
             /* Decoding only attributes */
-            ctx->coded_width = ctx->width;
-            ctx->coded_height = ctx->height;
+            // this setting will be automatically fetched from the bitstream.
+            //ctx->coded_width = ff->param.dec_fmt.det.vid.size.w;
+            //ctx->coded_height = ff->param.dec_fmt.det.vid.size.h;
 
             /* For decoder, be more flexible */
-            if (ff->param.dir!=PJMEDIA_DIR_ENCODING_DECODING || ff->enc!=ff->dec)
+            if (ff->param.dir!=PJMEDIA_DIR_ENCODING_DECODING || 
+                ff->enc!=ff->dec)
+            {
                 ctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
-
-            //ctx->get_format = &ffdec_nego_format;
+            }
+
+            ctx->get_format = &dec_get_format;
         }
 
@@ -680 +973 @@
     ff = (ffmpeg_private*)codec->codec_data;
 
-    ff->vfi = pjmedia_get_video_format_info(NULL, attr->dec_fmt.id);
-    if (!ff->vfi) {
-        status = PJ_EINVAL;
-        goto on_error;
-    }
-
-    pj_bzero(&ff->vafp, sizeof(ff->vafp));
-    ff->vafp.size = attr->dec_fmt.det.vid.size;
-    ff->vafp.buffer = 0;
-    status = (*ff->vfi->apply_fmt)(ff->vfi, &ff->vafp);
-    if (status != PJ_SUCCESS) {
-        goto on_error;
-    }
-
     pj_memcpy(&ff->param, attr, sizeof(*attr));
 
+    /* Apply SDP fmtp attribute */
+    if (ff->desc->parse_fmtp) {
+        status = (*ff->desc->parse_fmtp)(ff);
+        if (status != PJ_SUCCESS)
+            goto on_error;
+    }
+
+    /* Open the codec */
     ff_mutex = ((struct ffmpeg_factory*)codec->factory)->mutex;
     status = open_ffmpeg_codec(ff, ff_mutex);
@@ -701 +988 @@
         goto on_error;
 
+    /* Init format info and apply-param of decoder */
+    ff->dec_vfi = pjmedia_get_video_format_info(NULL, ff->param.dec_fmt.id);
+    if (!ff->dec_vfi) {
+        status = PJ_EINVAL;
+        goto on_error;
+    }
+    pj_bzero(&ff->dec_vafp, sizeof(ff->dec_vafp));
+    ff->dec_vafp.size = ff->param.dec_fmt.det.vid.size;
+    ff->dec_vafp.buffer = NULL;
+    status = (*ff->dec_vfi->apply_fmt)(ff->dec_vfi, &ff->dec_vafp);
+    if (status != PJ_SUCCESS) {
+        goto on_error;
+    }
+
+    /* Init format info and apply-param of encoder */
+    ff->enc_vfi = pjmedia_get_video_format_info(NULL, ff->param.dec_fmt.id);
+    if (!ff->enc_vfi) {
+        status = PJ_EINVAL;
+        goto on_error;
+    }
+    pj_bzero(&ff->enc_vafp, sizeof(ff->enc_vafp));
+    ff->enc_vafp.size = ff->param.enc_fmt.det.vid.size;
+    ff->enc_vafp.buffer = NULL;
+    status = (*ff->enc_vfi->apply_fmt)(ff->enc_vfi, &ff->enc_vafp);
+    if (status != PJ_SUCCESS) {
+        goto on_error;
+    }
+
+    /* Update codec attributes, e.g: encoding format may be changed by
+     * SDP fmtp negotiation.
+     */
+    pj_memcpy(attr, &ff->param, sizeof(*attr));
+
     return PJ_SUCCESS;
 
@@ -729 +1049 @@
         av_free(ff->dec_ctx);
     }
-    if (ff->dec_parser_ctx) {
-        av_parser_close(ff->dec_parser_ctx);
-
+    if (ff->sws_ctx) {
+        sws_freeContext(ff->sws_ctx);
     }
     ff->enc_ctx = NULL;
     ff->dec_ctx = NULL;
-    ff->dec_parser_ctx = NULL;
+    ff->sws_ctx = NULL;
     pj_mutex_unlock(ff_mutex);
 
@@ -746 +1065 @@
  */
 static pj_status_t  ffmpeg_codec_modify( pjmedia_vid_codec *codec, 
-                                         const pjmedia_vid_codec_param *attr )
+                                         const pjmedia_vid_codec_param *attr)
 {
     ffmpeg_private *ff = (ffmpeg_private*)codec->codec_data;
@@ -755 +1074 @@
     return PJ_ENOTSUP;
 }
+
+static pj_status_t  ffmpeg_codec_get_param(pjmedia_vid_codec *codec,
+                                           pjmedia_vid_codec_param *param)
+{
+    ffmpeg_private *ff;
+
+    PJ_ASSERT_RETURN(codec && param, PJ_EINVAL);
+
+    ff = (ffmpeg_private*)codec->codec_data;
+    pj_memcpy(param, &ff->param, sizeof(*param));
+
+    return PJ_SUCCESS;
+}
+
 
 static pj_status_t  ffmpeg_packetize ( pjmedia_vid_codec *codec,
@@ -765 +1098 @@
     ffmpeg_private *ff = (ffmpeg_private*)codec->codec_data;
 
-    switch (ff->param.enc_fmt.id) {
-        case PJMEDIA_FORMAT_H263:
-            return pjmedia_h263_packetize(buf, buf_len, pos,
-                                          ff->param.enc_mtu, payload,
-                                          payload_len);
-            break;
-        default:
-            return PJ_ENOTSUP;
-    }
+    if (ff->desc->packetize) {
+        return (*ff->desc->packetize)(buf, buf_len, pos,
+                                      ff->param.enc_mtu, payload,
+                                      payload_len);
+    }
+
+    return PJ_ENOTSUP;
 }
 
@@ -784 +1115 @@
     ffmpeg_private *ff = (ffmpeg_private*)codec->codec_data;
 
-    switch (ff->param.enc_fmt.id) {
-        case PJMEDIA_FORMAT_H263:
-            return pjmedia_h263_unpacketize(payload, payload_len,
-                                            buf, buf_len);
-            break;
-        default:
-            return PJ_ENOTSUP;
-    }
-}
-
-#if 0
-/*
- * Pack encoded frame to RTP payload frames.
- */
-static pj_status_t  ffmpeg_codec_pack ( pjmedia_vid_codec *codec,
-                                        const pjmedia_frame *enc_frame,
-                                        unsigned *frame_cnt,
-                                        pjmedia_frame frames[])
-{
-    ffmpeg_private *ff = (ffmpeg_private*)codec->codec_data;
-    unsigned i;
-
-    /* Can only work when encoding MTU is set */
-    PJ_ASSERT_RETURN(ff->param.enc_mtu, PJ_EINVALIDOP);
-
-    /* Validate available payload number */
-    PJ_ASSERT_RETURN(ff->pack_frm_cnt <= *frame_cnt, PJ_EINVALIDOP);
-
-    /* Validate encoded bitstream */
-    PJ_ASSERT_RETURN(ff->pack_frm_cnt==0 || 
-                     ff->pack_frms[0].buf == enc_frame->buf,
-                     PJ_EINVAL);
-
-    /* Return the payloads */
-    *frame_cnt = ff->pack_frm_cnt;
-    for (i = 0; i < *frame_cnt; ++i)
-        frames[i] = ff->pack_frms[i];
-
-    return PJ_SUCCESS;
-}
-
-/*
- * Get frames in the packet.
- */
-static pj_status_t  ffmpeg_codec_parse( pjmedia_vid_codec *codec,
-                                        void *pkt,
-                                        pj_size_t pkt_size,
-                                        const pj_timestamp *ts,
-                                        pjmedia_frame *frame)
-{
-    ffmpeg_private *ff = (ffmpeg_private*)codec->codec_data;
-    pj_uint8_t *buf = frame->buf;
-    int buf_size = frame->size;
-    int processed;
-
-
-    if (!ff->dec_parser_ctx) {
-        ff->dec_parser_ctx = av_parser_init(ff->dec->id);
-        if (!ff->dec_parser_ctx)
-            return PJ_ENOTSUP;
-    }
-
-#if LIBAVCODEC_VERSION_MAJOR >= 52 && LIBAVCODEC_VERSION_MINOR >= 72
-    processed = av_parser_parse2(ff->dec_parser_ctx, ff->dec_ctx, 
-                                 &buf, &buf_size, (uint8_t*)pkt, pkt_size,
-                                 ts->u64, ts->u64, AV_NOPTS_VALUE);
-#else
-    processed = av_parser_parse (ff->dec_parser_ctx, ff->dec_ctx, 
-                                 &buf, &buf_size, (uint8_t*)pkt, pkt_size,
-                                 ts->u64, ts->u64);
-#endif
-
-    if (buf_size) {
-        frame->timestamp = *ts;
-        frame->size = buf_size;
-        return PJ_SUCCESS;
-    }
-
-    return PJ_EPENDING;
-}
-
-static void enc_got_payload(struct AVCodecContext *avctx,
-                            void *data, int size, int mb_nb)
-{
-    ffmpeg_private *ff = (ffmpeg_private*) avctx->opaque;
-    pjmedia_frame *payload;
-
-    pj_assert(ff->pack_frm_cnt < ff->pack_frm_max_cnt);
-    payload = &ff->pack_frms[ff->pack_frm_cnt++];
-    payload->buf = data;
-    payload->size = size;
-    payload->bit_info = mb_nb;
-}
-
-#endif
+    if (ff->desc->unpacketize) {
+        return (*ff->desc->unpacketize)(payload, payload_len,
+                                        buf, buf_len);
+    }
+    
+    return PJ_ENOTSUP;
+}
 
 
@@ -885 +1128 @@
  */
 static pj_status_t ffmpeg_codec_encode( pjmedia_vid_codec *codec, 
-                                        const struct pjmedia_frame *input,
+                                        const pjmedia_frame *input,
                                         unsigned output_buf_len, 
-                                        struct pjmedia_frame *output)
+                                        pjmedia_frame *output)
 {
     ffmpeg_private *ff = (ffmpeg_private*)codec->codec_data;
@@ -900 +1143 @@
     PJ_ASSERT_RETURN(ff->enc_ctx, PJ_EINVALIDOP);
 
-    /*
-    ff->pack_frm_cnt = 0;
-    */
     avcodec_get_frame_defaults(&avframe);
     
-    for (i = 0; i < ff->vfi->plane_cnt; ++i) {
+    for (i = 0; i < ff->enc_vfi->plane_cnt; ++i) {
         avframe.data[i] = p;
-        avframe.linesize[i] = ff->vafp.strides[i];
-        p += ff->vafp.plane_bytes[i];
+        avframe.linesize[i] = ff->enc_vafp.strides[i];
+        p += ff->enc_vafp.plane_bytes[i];
     }
 
@@ -946 +1186 @@
  */
 static pj_status_t ffmpeg_codec_decode( pjmedia_vid_codec *codec, 
-                                        const struct pjmedia_frame *input,
+                                        const pjmedia_frame *input,
                                         unsigned output_buf_len, 
-                                        struct pjmedia_frame *output)
+                                        pjmedia_frame *output)
 {
     ffmpeg_private *ff = (ffmpeg_private*)codec->codec_data;
@@ -958 +1198 @@
     PJ_ASSERT_RETURN(ff->dec_ctx, PJ_EINVALIDOP);
 
-    PJ_UNUSED_ARG(output_buf_len);
+    /* Validate output buffer size */
+    PJ_ASSERT_RETURN(ff->dec_vafp.framebytes <= output_buf_len, PJ_ETOOSMALL);
 
     /* Init frame to receive the decoded data, the ffmpeg codec context will
@@ -979 +1220 @@
      */
     pj_bzero(avpacket.data+avpacket.size, FF_INPUT_BUFFER_PADDING_SIZE);
+
+    output->bit_info = 0;
 
 #if LIBAVCODEC_VERSION_MAJOR >= 52 && LIBAVCODEC_VERSION_MINOR >= 72
@@ -997 +1240 @@
         return PJ_EUNKNOWN;
     } else if (got_picture) {
-        pjmedia_video_apply_fmt_param *vafp = (pjmedia_video_apply_fmt_param*)
-                                              &ff->vafp;
+        pjmedia_video_apply_fmt_param *vafp = &ff->dec_vafp;
         pj_uint8_t *q = (pj_uint8_t*)output->buf;
-        unsigned i;
-
-        /* Get the decoded data */
-        for (i = 0; i < ff->vfi->plane_cnt; ++i) {
-            pj_uint8_t *p = avframe.data[i];
-
-            /* The decoded data may contain padding */
-            if (avframe.linesize[i]==vafp->strides[i]) {
-                /* No padding, copy the whole plane */
-                pj_memcpy(q, p, vafp->plane_bytes[i]);
-                q += vafp->plane_bytes[i];
-            } else {
-                /* Padding exists, copy line by line */
-                pj_uint8_t *q_end;
-                
-                q_end = q+vafp->plane_bytes[i];
-                while(q < q_end) {
-                    pj_memcpy(q, p, vafp->strides[i]);
-                    q += vafp->strides[i];
-                    p += avframe.linesize[i];
-                }
-            }
-        }
+        unsigned i;
+
+        /* Decoder output format is set by libavcodec, in case it is different
+         * to the configured param.
+         */
+        if (ff->dec_ctx->pix_fmt != ff->expected_dec_fmt ||
+            ff->dec_ctx->coded_width != (int)vafp->size.w ||
+            ff->dec_ctx->coded_height != (int)vafp->size.h)
+        {
+#if 0       
+            // it should not be the codec responsibility to do resizing
+            pj_uint8_t *data[PJMEDIA_MAX_VIDEO_PLANES] = {0};
+            unsigned i;
+            int h;
+
+            if (!ff->sws_ctx) {
+                pj_assert(sws_isSupportedInput(ff->dec_ctx->pix_fmt) > 0);
+                pj_assert(sws_isSupportedOutput(ff->expected_dec_fmt) > 0);
+                ff->sws_ctx = sws_getContext(ff->dec_ctx->coded_width,
+                                             ff->dec_ctx->coded_height,
+                                             ff->dec_ctx->pix_fmt,
+                                             vafp->size.w, vafp->size.h,
+                                             ff->expected_dec_fmt,
+                                             SWS_BILINEAR | SWS_PRINT_INFO,
+                                             NULL, NULL, NULL);
+                if (ff->sws_ctx == NULL) {
+                    return PJ_EUNKNOWN;
+                }
+            }
+
+            for (i = 0; i < ff->vfi->plane_cnt; ++i) {
+                data[i] = q;
+                q += vafp->plane_bytes[i];
+            }
+            h = sws_scale(ff->sws_ctx, avframe.data, avframe.linesize, 0, 
+                          ff->dec_ctx->coded_height, data, vafp->strides);
+            pj_assert((int)vafp->size.h == h);
+#endif
+
+            pjmedia_format_id new_fmt_id;
+            pj_status_t status;
+
+            /* Get current raw format id from ffmpeg decoder context */
+            status = PixelFormat_to_pjmedia_format_id(ff->dec_ctx->pix_fmt, 
+                                                      &new_fmt_id);
+            if (status != PJ_SUCCESS)
+                return status;
+
+            /* Update decoder format in param */
+            ff->param.dec_fmt.id = new_fmt_id;
+            ff->param.dec_fmt.det.vid.size.w = ff->dec_ctx->coded_width;
+            ff->param.dec_fmt.det.vid.size.h = ff->dec_ctx->coded_height;
+
+            /* Re-init format info and apply-param of decoder */
+            ff->dec_vfi = pjmedia_get_video_format_info(NULL, ff->param.dec_fmt.id);
+            if (!ff->dec_vfi)
+                return PJ_EUNKNOWN;
+            pj_bzero(&ff->dec_vafp, sizeof(ff->dec_vafp));
+            ff->dec_vafp.size = ff->param.dec_fmt.det.vid.size;
+            ff->dec_vafp.buffer = NULL;
+            status = (*ff->dec_vfi->apply_fmt)(ff->dec_vfi, &ff->dec_vafp);
+            if (status != PJ_SUCCESS)
+                return status;
+
+            /* Notify application via the bit_info field of pjmedia_frame */
+            output->bit_info = PJMEDIA_VID_CODEC_EVENT_FMT_CHANGED;
+        }
+
+        /* Check provided buffer size after format changed */
+        if (vafp->framebytes > output_buf_len)
+            return PJ_ETOOSMALL;
+
+        /* Get the decoded data */
+        for (i = 0; i < ff->dec_vfi->plane_cnt; ++i) {
+            pj_uint8_t *p = avframe.data[i];
+
+            /* The decoded data may contain padding */
+            if (avframe.linesize[i]!=vafp->strides[i]) {
+                /* Padding exists, copy line by line */
+                pj_uint8_t *q_end;
+                    
+                q_end = q+vafp->plane_bytes[i];
+                while(q < q_end) {
+                    pj_memcpy(q, p, vafp->strides[i]);
+                    q += vafp->strides[i];
+                    p += avframe.linesize[i];
+                }
+            } else {
+                /* No padding, copy the whole plane */
+                pj_memcpy(q, p, vafp->plane_bytes[i]);
+                q += vafp->plane_bytes[i];
+            }
+        }
+
         output->size = vafp->framebytes;
     } else {
@@ -1036 +1349 @@
 static pj_status_t  ffmpeg_codec_recover( pjmedia_vid_codec *codec, 
                                           unsigned output_buf_len, 
-                                          struct pjmedia_frame *output)
-{
-    ffmpeg_private *ff = (ffmpeg_private*)codec->codec_data;
-
+                                          pjmedia_frame *output)
+{
+    PJ_UNUSED_ARG(codec);
     PJ_UNUSED_ARG(output_buf_len);
     PJ_UNUSED_ARG(output);
-    PJ_UNUSED_ARG(ff);
-
-    return PJ_SUCCESS;
+
+    return PJ_ENOTSUP;
 }
 
 #ifdef _MSC_VER
 #   pragma comment( lib, "avcodec.lib")
+#   pragma comment( lib, "swscale.lib")
 #endif
 

pjproject/branches/projects/2.0-dev/pjmedia/src/pjmedia-videodev/colorbar_dev.c

@@ -81 +81 @@
 struct cbar_stream
 {
-    pjmedia_vid_stream   base;              /**< Base stream           */
-    pjmedia_vid_param    param;             /**< Settings              */
-    pj_pool_t           *pool;              /**< Memory pool.          */
-
-    pjmedia_vid_cb       vid_cb;            /**< Stream callback.      */
-    void                *user_data;         /**< Application data.     */
+    pjmedia_vid_dev_stream           base;          /**< Base stream        */
+    pjmedia_vid_param                param;         /**< Settings           */
+    pj_pool_t                       *pool;          /**< Memory pool.       */
+
+    pjmedia_vid_cb                   vid_cb;        /**< Stream callback.   */
+    void                            *user_data;     /**< Application data.  */
 
     const struct cbar_fmt_info      *cbfi;
@@ -106 +106 @@
                                               unsigned index,
                                               pjmedia_vid_param *param);
-static pj_status_t cbar_factory_create_stream(pjmedia_vid_dev_factory *f,
-                                              const pjmedia_vid_param *param,
-                                              const pjmedia_vid_cb *cb,
-                                              void *user_data,
-                                              pjmedia_vid_stream **p_vid_strm);
-
-static pj_status_t cbar_stream_get_param(pjmedia_vid_stream *strm,
+static pj_status_t cbar_factory_create_stream(
+                                        pjmedia_vid_dev_factory *f,
+                                        const pjmedia_vid_param *param,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm);
+
+static pj_status_t cbar_stream_get_param(pjmedia_vid_dev_stream *strm,
                                          pjmedia_vid_param *param);
-static pj_status_t cbar_stream_get_cap(pjmedia_vid_stream *strm,
+static pj_status_t cbar_stream_get_cap(pjmedia_vid_dev_stream *strm,
                                        pjmedia_vid_dev_cap cap,
                                        void *value);
-static pj_status_t cbar_stream_set_cap(pjmedia_vid_stream *strm,
+static pj_status_t cbar_stream_set_cap(pjmedia_vid_dev_stream *strm,
                                        pjmedia_vid_dev_cap cap,
                                        const void *value);
-static pj_status_t cbar_stream_get_frame(pjmedia_vid_stream *strm,
+static pj_status_t cbar_stream_get_frame(pjmedia_vid_dev_stream *strm,
                                          pjmedia_frame *frame);
-static pj_status_t cbar_stream_start(pjmedia_vid_stream *strm);
-static pj_status_t cbar_stream_stop(pjmedia_vid_stream *strm);
-static pj_status_t cbar_stream_destroy(pjmedia_vid_stream *strm);
+static pj_status_t cbar_stream_start(pjmedia_vid_dev_stream *strm);
+static pj_status_t cbar_stream_stop(pjmedia_vid_dev_stream *strm);
+static pj_status_t cbar_stream_destroy(pjmedia_vid_dev_stream *strm);
 
 /* Operations */
@@ -137 +138 @@
 };
 
-static pjmedia_vid_stream_op stream_op =
+static pjmedia_vid_dev_stream_op stream_op =
 {
     &cbar_stream_get_param,
@@ -355 +356 @@
 
 /* API: create stream */
-static pj_status_t cbar_factory_create_stream(pjmedia_vid_dev_factory *f,
-                                              const pjmedia_vid_param *param,
-                                              const pjmedia_vid_cb *cb,
-                                              void *user_data,
-                                              pjmedia_vid_stream **p_vid_strm)
+static pj_status_t cbar_factory_create_stream(
+                                        pjmedia_vid_dev_factory *f,
+                                        const pjmedia_vid_param *param,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm)
 {
     struct cbar_factory *cf = (struct cbar_factory*)f;
@@ -420 +422 @@
 
 /* API: Get stream info. */
-static pj_status_t cbar_stream_get_param(pjmedia_vid_stream *s,
+static pj_status_t cbar_stream_get_param(pjmedia_vid_dev_stream *s,
                                          pjmedia_vid_param *pi)
 {
@@ -439 +441 @@
 
 /* API: get capability */
-static pj_status_t cbar_stream_get_cap(pjmedia_vid_stream *s,
+static pj_status_t cbar_stream_get_cap(pjmedia_vid_dev_stream *s,
                                        pjmedia_vid_dev_cap cap,
                                        void *pval)
@@ -459 +461 @@
 
 /* API: set capability */
-static pj_status_t cbar_stream_set_cap(pjmedia_vid_stream *s,
+static pj_status_t cbar_stream_set_cap(pjmedia_vid_dev_stream *s,
                                        pjmedia_vid_dev_cap cap,
                                        const void *pval)
@@ -553 +555 @@
 
 /* API: Get frame from stream */
-static pj_status_t cbar_stream_get_frame(pjmedia_vid_stream *strm,
+static pj_status_t cbar_stream_get_frame(pjmedia_vid_dev_stream *strm,
                                          pjmedia_frame *frame)
 {
@@ -562 +564 @@
 
 /* API: Start stream. */
-static pj_status_t cbar_stream_start(pjmedia_vid_stream *strm)
+static pj_status_t cbar_stream_start(pjmedia_vid_dev_stream *strm)
 {
     struct cbar_stream *stream = (struct cbar_stream*)strm;
@@ -574 +576 @@
 
 /* API: Stop stream. */
-static pj_status_t cbar_stream_stop(pjmedia_vid_stream *strm)
+static pj_status_t cbar_stream_stop(pjmedia_vid_dev_stream *strm)
 {
     struct cbar_stream *stream = (struct cbar_stream*)strm;
@@ -587 +589 @@
 
 /* API: Destroy stream. */
-static pj_status_t cbar_stream_destroy(pjmedia_vid_stream *strm)
+static pj_status_t cbar_stream_destroy(pjmedia_vid_dev_stream *strm)
 {
     struct cbar_stream *stream = (struct cbar_stream*)strm;

pjproject/branches/projects/2.0-dev/pjmedia/src/pjmedia-videodev/dshow_dev.c

@@ -90 +90 @@
 struct dshow_stream
 {
-    pjmedia_vid_stream   base;              /**< Base stream           */
-    pjmedia_vid_param    param;             /**< Settings              */
-    pj_pool_t           *pool;              /**< Memory pool.          */
-
-    pjmedia_vid_cb       vid_cb;            /**< Stream callback.     */
-    void                *user_data;         /**< Application data.     */
-
-    pj_bool_t            quit_flag;
-    pj_bool_t            rend_thread_exited;
-    pj_bool_t            cap_thread_exited;
-    pj_bool_t            cap_thread_initialized;
-    pj_thread_desc       cap_thread_desc;
-    pj_thread_t         *cap_thread;
+    pjmedia_vid_dev_stream   base;                  /**< Base stream        */
+    pjmedia_vid_param        param;                 /**< Settings           */
+    pj_pool_t               *pool;                  /**< Memory pool.       */
+
+    pjmedia_vid_cb           vid_cb;                /**< Stream callback.   */
+    void                    *user_data;             /**< Application data.  */
+
+    pj_bool_t                quit_flag;
+    pj_bool_t                rend_thread_exited;
+    pj_bool_t                cap_thread_exited;
+    pj_bool_t                cap_thread_initialized;
+    pj_thread_desc           cap_thread_desc;
+    pj_thread_t             *cap_thread;
 
     struct dshow_graph
@@ -127 +127 @@
                                                unsigned index,
                                                pjmedia_vid_param *param);
-static pj_status_t dshow_factory_create_stream(pjmedia_vid_dev_factory *f,
-                                               const pjmedia_vid_param *param,
-                                               const pjmedia_vid_cb *cb,
-                                               void *user_data,
-                                               pjmedia_vid_stream **p_vid_strm);
-
-static pj_status_t dshow_stream_get_param(pjmedia_vid_stream *strm,
+static pj_status_t dshow_factory_create_stream(
+                                        pjmedia_vid_dev_factory *f,
+                                        const pjmedia_vid_param *param,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm);
+
+static pj_status_t dshow_stream_get_param(pjmedia_vid_dev_stream *strm,
                                           pjmedia_vid_param *param);
-static pj_status_t dshow_stream_get_cap(pjmedia_vid_stream *strm,
+static pj_status_t dshow_stream_get_cap(pjmedia_vid_dev_stream *strm,
                                         pjmedia_vid_dev_cap cap,
                                         void *value);
-static pj_status_t dshow_stream_set_cap(pjmedia_vid_stream *strm,
+static pj_status_t dshow_stream_set_cap(pjmedia_vid_dev_stream *strm,
                                         pjmedia_vid_dev_cap cap,
                                         const void *value);
-static pj_status_t dshow_stream_start(pjmedia_vid_stream *strm);
-static pj_status_t dshow_stream_put_frame(pjmedia_vid_stream *strm,
+static pj_status_t dshow_stream_start(pjmedia_vid_dev_stream *strm);
+static pj_status_t dshow_stream_put_frame(pjmedia_vid_dev_stream *strm,
                                           const pjmedia_frame *frame);
-static pj_status_t dshow_stream_stop(pjmedia_vid_stream *strm);
-static pj_status_t dshow_stream_destroy(pjmedia_vid_stream *strm);
+static pj_status_t dshow_stream_stop(pjmedia_vid_dev_stream *strm);
+static pj_status_t dshow_stream_destroy(pjmedia_vid_dev_stream *strm);
 
 /* Operations */
@@ -158 +159 @@
 };
 
-static pjmedia_vid_stream_op stream_op =
+static pjmedia_vid_dev_stream_op stream_op =
 {
     &dshow_stream_get_param,
@@ -396 +397 @@
     /* Set the device capabilities here */
     param->clock_rate = DEFAULT_CLOCK_RATE;
-    param->frame_rate.num = DEFAULT_FPS;
-    param->frame_rate.denum = 1;
+    //param->frame_rate.num = DEFAULT_FPS;
+    //param->frame_rate.denum = 1;
     param->flags = PJMEDIA_VID_DEV_CAP_FORMAT;
 
@@ -439 +440 @@
 
 /* API: Put frame from stream */
-static pj_status_t dshow_stream_put_frame(pjmedia_vid_stream *strm,
+static pj_status_t dshow_stream_put_frame(pjmedia_vid_dev_stream *strm,
                                           const pjmedia_frame *frame)
 {
@@ -698 +699 @@
 
 /* API: create stream */
-static pj_status_t dshow_factory_create_stream(pjmedia_vid_dev_factory *f,
-                                               const pjmedia_vid_param *param,
-                                               const pjmedia_vid_cb *cb,
-                                               void *user_data,
-                                               pjmedia_vid_stream **p_vid_strm)
+static pj_status_t dshow_factory_create_stream(
+                                        pjmedia_vid_dev_factory *f,
+                                        const pjmedia_vid_param *param,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm)
 {
     struct dshow_factory *df = (struct dshow_factory*)f;
@@ -753 +755 @@
  
 on_error:
-    dshow_stream_destroy((pjmedia_vid_stream *)strm);
+    dshow_stream_destroy((pjmedia_vid_dev_stream *)strm);
     return PJ_EUNKNOWN;
 }
 
 /* API: Get stream info. */
-static pj_status_t dshow_stream_get_param(pjmedia_vid_stream *s,
+static pj_status_t dshow_stream_get_param(pjmedia_vid_dev_stream *s,
                                           pjmedia_vid_param *pi)
 {
@@ -777 +779 @@
 
 /* API: get capability */
-static pj_status_t dshow_stream_get_cap(pjmedia_vid_stream *s,
+static pj_status_t dshow_stream_get_cap(pjmedia_vid_dev_stream *s,
                                         pjmedia_vid_dev_cap cap,
                                         void *pval)
@@ -797 +799 @@
 
 /* API: set capability */
-static pj_status_t dshow_stream_set_cap(pjmedia_vid_stream *s,
+static pj_status_t dshow_stream_set_cap(pjmedia_vid_dev_stream *s,
                                         pjmedia_vid_dev_cap cap,
                                         const void *pval)
@@ -817 +819 @@
 
 /* API: Start stream. */
-static pj_status_t dshow_stream_start(pjmedia_vid_stream *strm)
+static pj_status_t dshow_stream_start(pjmedia_vid_dev_stream *strm)
 {
     struct dshow_stream *stream = (struct dshow_stream*)strm;
@@ -843 +845 @@
 
 /* API: Stop stream. */
-static pj_status_t dshow_stream_stop(pjmedia_vid_stream *strm)
+static pj_status_t dshow_stream_stop(pjmedia_vid_dev_stream *strm)
 {
     struct dshow_stream *stream = (struct dshow_stream*)strm;
@@ -869 +871 @@
 
 /* API: Destroy stream. */
-static pj_status_t dshow_stream_destroy(pjmedia_vid_stream *strm)
+static pj_status_t dshow_stream_destroy(pjmedia_vid_dev_stream *strm)
 {
     struct dshow_stream *stream = (struct dshow_stream*)strm;

pjproject/branches/projects/2.0-dev/pjmedia/src/pjmedia-videodev/ffmpeg_dev.c

@@ -68 +68 @@
 typedef struct ffmpeg_stream
 {
-    pjmedia_vid_stream           base;
+    pjmedia_vid_dev_stream       base;
     ffmpeg_factory              *factory;
     pj_pool_t                   *pool;
@@ -81 +81 @@
 static unsigned    ffmpeg_factory_get_dev_count(pjmedia_vid_dev_factory *f);
 static pj_status_t ffmpeg_factory_get_dev_info(pjmedia_vid_dev_factory *f,
-                                              unsigned index,
-                                              pjmedia_vid_dev_info *info);
+                                               unsigned index,
+                                               pjmedia_vid_dev_info *info);
 static pj_status_t ffmpeg_factory_default_param(pj_pool_t *pool,
                                                 pjmedia_vid_dev_factory *f,
                                                 unsigned index,
                                                 pjmedia_vid_param *param);
-static pj_status_t ffmpeg_factory_create_stream(pjmedia_vid_dev_factory *f,
-                                               const pjmedia_vid_param *param,
-                                               const pjmedia_vid_cb *cb,
-                                               void *user_data,
-                                               pjmedia_vid_stream **p_vid_strm);
-
-static pj_status_t ffmpeg_stream_get_param(pjmedia_vid_stream *strm,
-                                          pjmedia_vid_param *param);
-static pj_status_t ffmpeg_stream_get_cap(pjmedia_vid_stream *strm,
-                                        pjmedia_vid_dev_cap cap,
-                                        void *value);
-static pj_status_t ffmpeg_stream_set_cap(pjmedia_vid_stream *strm,
-                                        pjmedia_vid_dev_cap cap,
-                                        const void *value);
-static pj_status_t ffmpeg_stream_start(pjmedia_vid_stream *strm);
-static pj_status_t ffmpeg_stream_get_frame(pjmedia_vid_stream *s,
+static pj_status_t ffmpeg_factory_create_stream(
+                                        pjmedia_vid_dev_factory *f,
+                                        const pjmedia_vid_param *param,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm);
+
+static pj_status_t ffmpeg_stream_get_param(pjmedia_vid_dev_stream *strm,
+                                           pjmedia_vid_param *param);
+static pj_status_t ffmpeg_stream_get_cap(pjmedia_vid_dev_stream *strm,
+                                         pjmedia_vid_dev_cap cap,
+                                         void *value);
+static pj_status_t ffmpeg_stream_set_cap(pjmedia_vid_dev_stream *strm,
+                                         pjmedia_vid_dev_cap cap,
+                                         const void *value);
+static pj_status_t ffmpeg_stream_start(pjmedia_vid_dev_stream *strm);
+static pj_status_t ffmpeg_stream_get_frame(pjmedia_vid_dev_stream *s,
                                            pjmedia_frame *frame);
-static pj_status_t ffmpeg_stream_stop(pjmedia_vid_stream *strm);
-static pj_status_t ffmpeg_stream_destroy(pjmedia_vid_stream *strm);
+static pj_status_t ffmpeg_stream_stop(pjmedia_vid_dev_stream *strm);
+static pj_status_t ffmpeg_stream_destroy(pjmedia_vid_dev_stream *strm);
 
 /* Operations */
@@ -118 +119 @@
 };
 
-static pjmedia_vid_stream_op stream_op =
+static pjmedia_vid_dev_stream_op stream_op =
 {
     &ffmpeg_stream_get_param,
@@ -153 +154 @@
 {
     AVFormatParameters fp;
-    pjmedia_video_format_detail *fmt_detail;
+    pjmedia_video_format_detail *vfd;
     int err;
 
@@ -160 +161 @@
                      PJ_EINVAL);
 
-    fmt_detail = (pjmedia_video_format_detail*)param->fmt.detail;
+    vfd = pjmedia_format_get_video_format_detail(&param->fmt, PJ_TRUE);
 
     /* Init ffmpeg format context */
@@ -168 +169 @@
     pj_bzero(&fp, sizeof(fp));
     fp.prealloced_context = 1;
-    fp.width = fmt_detail->size.w;
-    fp.height = fmt_detail->size.h;
+    fp.width = vfd->size.w;
+    fp.height = vfd->size.h;
     fp.pix_fmt = PIX_FMT_BGR24;
-    fp.time_base.num = param->frame_rate.denum;
-    fp.time_base.den = param->frame_rate.num;
+    fp.time_base.num = vfd->fps.denum;
+    fp.time_base.den = vfd->fps.num;
 
     /* Open capture stream */
@@ -289 +290 @@
 /* API: get device info */
 static pj_status_t ffmpeg_factory_get_dev_info(pjmedia_vid_dev_factory *f,
-                                              unsigned index,
-                                              pjmedia_vid_dev_info *info)
+                                               unsigned index,
+                                               pjmedia_vid_dev_info *info)
 {
     ffmpeg_factory *ff = (ffmpeg_factory*)f;
@@ -309 +310 @@
     ffmpeg_factory *ff = (ffmpeg_factory*)f;
     ffmpeg_dev_info *info;
-    pjmedia_video_format_detail *fmt_detail;
 
     PJ_ASSERT_RETURN(index < ff->dev_count, PJMEDIA_EVID_INVDEV);
+
+    PJ_UNUSED_ARG(pool);
+
     info = &ff->dev_info[index];
 
@@ -322 +325 @@
     /* Set the device capabilities here */
     param->flags = PJMEDIA_VID_DEV_CAP_FORMAT;
-    pj_memcpy(&param->fmt, &info->base.fmt[0], sizeof(param->fmt));
     param->clock_rate = 90000;
-    pjmedia_format_init_video(pool, &param->fmt, 320, 240, 25, 1,
-                              0, 0);
-    fmt_detail = (pjmedia_video_format_detail*)param->fmt.detail;
-    param->frame_rate.num = fmt_detail->fps.num;
-    param->frame_rate.denum = fmt_detail->fps.denum;
+    pjmedia_format_init_video(&param->fmt, 0, 320, 240, 25, 1);
+    param->fmt.id = info->base.fmt[0].id;
 
     return PJ_SUCCESS;
@@ -336 +335 @@
 
 /* API: create stream */
-static pj_status_t ffmpeg_factory_create_stream(pjmedia_vid_dev_factory *f,
-                                               const pjmedia_vid_param *param,
-                                               const pjmedia_vid_cb *cb,
-                                               void *user_data,
-                                               pjmedia_vid_stream **p_vid_strm)
+static pj_status_t ffmpeg_factory_create_stream(
+                                        pjmedia_vid_dev_factory *f,
+                                        const pjmedia_vid_param *param,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm)
 {
     ffmpeg_factory *ff = (ffmpeg_factory*)f;
@@ -349 +349 @@
     PJ_ASSERT_RETURN(param->dir == PJMEDIA_DIR_CAPTURE, PJ_EINVAL);
     PJ_ASSERT_RETURN((unsigned)param->cap_id < ff->dev_count, PJ_EINVAL);
-    PJ_ASSERT_RETURN(param->fmt.detail_type == PJMEDIA_FORMAT_DETAIL_VIDEO &&
-                     param->fmt.detail, PJ_EINVAL);
+    PJ_ASSERT_RETURN(param->fmt.detail_type == PJMEDIA_FORMAT_DETAIL_VIDEO,
+                     PJ_EINVAL);
 
     PJ_UNUSED_ARG(cb);
@@ -372 +372 @@
 
 /* API: Get stream info. */
-static pj_status_t ffmpeg_stream_get_param(pjmedia_vid_stream *s,
+static pj_status_t ffmpeg_stream_get_param(pjmedia_vid_dev_stream *s,
                                            pjmedia_vid_param *pi)
 {
@@ -385 +385 @@
 
 /* API: get capability */
-static pj_status_t ffmpeg_stream_get_cap(pjmedia_vid_stream *s,
-                                        pjmedia_vid_dev_cap cap,
-                                        void *pval)
+static pj_status_t ffmpeg_stream_get_cap(pjmedia_vid_dev_stream *s,
+                                         pjmedia_vid_dev_cap cap,
+                                         void *pval)
 {
     ffmpeg_stream *strm = (ffmpeg_stream*)s;
@@ -399 +399 @@
 
 /* API: set capability */
-static pj_status_t ffmpeg_stream_set_cap(pjmedia_vid_stream *s,
-                                        pjmedia_vid_dev_cap cap,
-                                        const void *pval)
+static pj_status_t ffmpeg_stream_set_cap(pjmedia_vid_dev_stream *s,
+                                         pjmedia_vid_dev_cap cap,
+                                         const void *pval)
 {
     ffmpeg_stream *strm = (ffmpeg_stream*)s;
@@ -414 +414 @@
 
 /* API: Start stream. */
-static pj_status_t ffmpeg_stream_start(pjmedia_vid_stream *s)
+static pj_status_t ffmpeg_stream_start(pjmedia_vid_dev_stream *s)
 {
     ffmpeg_stream *strm = (ffmpeg_stream*)s;
@@ -436 +436 @@
 
 /* API: Get frame from stream */
-static pj_status_t ffmpeg_stream_get_frame(pjmedia_vid_stream *s,
+static pj_status_t ffmpeg_stream_get_frame(pjmedia_vid_dev_stream *s,
                                            pjmedia_frame *frame)
 {
@@ -459 +459 @@
 
 /* API: Stop stream. */
-static pj_status_t ffmpeg_stream_stop(pjmedia_vid_stream *s)
+static pj_status_t ffmpeg_stream_stop(pjmedia_vid_dev_stream *s)
 {
     ffmpeg_stream *strm = (ffmpeg_stream*)s;
@@ -473 +473 @@
 
 /* API: Destroy stream. */
-static pj_status_t ffmpeg_stream_destroy(pjmedia_vid_stream *s)
+static pj_status_t ffmpeg_stream_destroy(pjmedia_vid_dev_stream *s)
 {
     ffmpeg_stream *strm = (ffmpeg_stream*)s;

pjproject/branches/projects/2.0-dev/pjmedia/src/pjmedia-videodev/sdl_dev.c

@@ -91 +91 @@
 struct sdl_stream
 {
-    pjmedia_vid_stream   base;              /**< Base stream           */
-    pjmedia_vid_param    param;             /**< Settings              */
-    pj_pool_t           *pool;              /**< Memory pool.          */
-
-    pjmedia_vid_cb       vid_cb;            /**< Stream callback.      */
-    void                *user_data;         /**< Application data.     */
-
-    pj_thread_t         *sdl_thread;        /**< SDL thread.           */
-    pj_bool_t            is_quitting;
-    pj_bool_t            is_running;
-    pj_bool_t            render_exited;
-    pj_status_t          status;
-
-    SDL_Rect             rect;              /**< Display rectangle.    */
-    SDL_Surface         *screen;            /**< Display screen.       */
-    SDL_Surface         *surf;              /**< RGB surface.          */
-    SDL_Overlay         *overlay;           /**< YUV overlay.          */
+    pjmedia_vid_dev_stream       base;              /**< Base stream        */
+    pjmedia_vid_param            param;             /**< Settings           */
+    pj_pool_t                   *pool;              /**< Memory pool.       */
+
+    pjmedia_vid_cb               vid_cb;            /**< Stream callback.   */
+    void                        *user_data;         /**< Application data.  */
+
+    pj_thread_t                 *sdl_thread;        /**< SDL thread.        */
+    pj_bool_t                    is_quitting;
+    pj_bool_t                    is_running;
+    pj_bool_t                    render_exited;
+    pj_status_t                  status;
+
+    SDL_Rect                     rect;              /**< Display rectangle. */
+    SDL_Surface                 *screen;            /**< Display screen.    */
+    SDL_Surface                 *surf;              /**< RGB surface.       */
+    SDL_Overlay                 *overlay;           /**< YUV overlay.       */
 
     /* For frame conversion */
-    pjmedia_converter       *conv;
-    pjmedia_conversion_param conv_param;
-    pjmedia_frame            conv_buf;
+    pjmedia_converter           *conv;
+    pjmedia_conversion_param     conv_param;
+    pjmedia_frame                conv_buf;
 
     pjmedia_video_apply_fmt_param vafp;
@@ -129 +129 @@
                                              unsigned index,
                                              pjmedia_vid_param *param);
-static pj_status_t sdl_factory_create_stream(pjmedia_vid_dev_factory *f,
-                                             const pjmedia_vid_param *param,
-                                             const pjmedia_vid_cb *cb,
-                                             void *user_data,
-                                             pjmedia_vid_stream **p_vid_strm);
-
-static pj_status_t sdl_stream_get_param(pjmedia_vid_stream *strm,
+static pj_status_t sdl_factory_create_stream(
+                                        pjmedia_vid_dev_factory *f,
+                                        const pjmedia_vid_param *param,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm);
+
+static pj_status_t sdl_stream_get_param(pjmedia_vid_dev_stream *strm,
                                         pjmedia_vid_param *param);
-static pj_status_t sdl_stream_get_cap(pjmedia_vid_stream *strm,
+static pj_status_t sdl_stream_get_cap(pjmedia_vid_dev_stream *strm,
                                       pjmedia_vid_dev_cap cap,
                                       void *value);
-static pj_status_t sdl_stream_set_cap(pjmedia_vid_stream *strm,
+static pj_status_t sdl_stream_set_cap(pjmedia_vid_dev_stream *strm,
                                       pjmedia_vid_dev_cap cap,
                                       const void *value);
-static pj_status_t sdl_stream_put_frame(pjmedia_vid_stream *strm,
+static pj_status_t sdl_stream_put_frame(pjmedia_vid_dev_stream *strm,
                                         const pjmedia_frame *frame);
-static pj_status_t sdl_stream_start(pjmedia_vid_stream *strm);
-static pj_status_t sdl_stream_stop(pjmedia_vid_stream *strm);
-static pj_status_t sdl_stream_destroy(pjmedia_vid_stream *strm);
+static pj_status_t sdl_stream_start(pjmedia_vid_dev_stream *strm);
+static pj_status_t sdl_stream_stop(pjmedia_vid_dev_stream *strm);
+static pj_status_t sdl_stream_destroy(pjmedia_vid_dev_stream *strm);
 
 /* Operations */
@@ -160 +161 @@
 };
 
-static pjmedia_vid_stream_op stream_op =
+static pjmedia_vid_dev_stream_op stream_op =
 {
     &sdl_stream_get_param,
@@ -408 +409 @@
                         }
                     if (strm->is_running)
-                        pjmedia_vid_stream_stop(&strm->base);
+                        pjmedia_vid_dev_stream_stop(&strm->base);
                     else
-                        pjmedia_vid_stream_start(&strm->base);
+                        pjmedia_vid_dev_stream_start(&strm->base);
                     break;
                 case SDL_VIDEORESIZE:
@@ -434 +435 @@
                      * To process PJMEDIA_EVENT_WINDOW_CLOSE event,
                      * application should do this in the on_event_cb callback:
-                     * 1. stop further calls to #pjmedia_vid_stream_put_frame()
+                     * 1. stop further calls to 
+                     *    #pjmedia_vid_dev_stream_put_frame()
                      * 2. return PJ_SUCCESS
                      * Upon returning from the callback, SDL will destroy its
@@ -484 +486 @@
 
 /* API: create stream */
-static pj_status_t sdl_factory_create_stream(pjmedia_vid_dev_factory *f,
-                                             const pjmedia_vid_param *param,
-                                             const pjmedia_vid_cb *cb,
-                                             void *user_data,
-                                             pjmedia_vid_stream **p_vid_strm)
+static pj_status_t sdl_factory_create_stream(
+                                        pjmedia_vid_dev_factory *f,
+                                        const pjmedia_vid_param *param,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm)
 {
     struct sdl_factory *sf = (struct sdl_factory*)f;
@@ -549 +552 @@
 
 /* API: Get stream info. */
-static pj_status_t sdl_stream_get_param(pjmedia_vid_stream *s,
+static pj_status_t sdl_stream_get_param(pjmedia_vid_dev_stream *s,
                                         pjmedia_vid_param *pi)
 {
@@ -568 +571 @@
 
 /* API: get capability */
-static pj_status_t sdl_stream_get_cap(pjmedia_vid_stream *s,
+static pj_status_t sdl_stream_get_cap(pjmedia_vid_dev_stream *s,
                                       pjmedia_vid_dev_cap cap,
                                       void *pval)
@@ -587 +590 @@
 
 /* API: set capability */
-static pj_status_t sdl_stream_set_cap(pjmedia_vid_stream *s,
+static pj_status_t sdl_stream_set_cap(pjmedia_vid_dev_stream *s,
                                       pjmedia_vid_dev_cap cap,
                                       const void *pval)
@@ -606 +609 @@
 
 /* API: Put frame from stream */
-static pj_status_t sdl_stream_put_frame(pjmedia_vid_stream *strm,
+static pj_status_t sdl_stream_put_frame(pjmedia_vid_dev_stream *strm,
                                         const pjmedia_frame *frame)
 {
@@ -665 +668 @@
 
 /* API: Start stream. */
-static pj_status_t sdl_stream_start(pjmedia_vid_stream *strm)
+static pj_status_t sdl_stream_start(pjmedia_vid_dev_stream *strm)
 {
     struct sdl_stream *stream = (struct sdl_stream*)strm;
@@ -678 +681 @@
 
 /* API: Stop stream. */
-static pj_status_t sdl_stream_stop(pjmedia_vid_stream *strm)
+static pj_status_t sdl_stream_stop(pjmedia_vid_dev_stream *strm)
 {
     struct sdl_stream *stream = (struct sdl_stream*)strm;
@@ -695 +698 @@
 
 /* API: Destroy stream. */
-static pj_status_t sdl_stream_destroy(pjmedia_vid_stream *strm)
+static pj_status_t sdl_stream_destroy(pjmedia_vid_dev_stream *strm)
 {
     struct sdl_stream *stream = (struct sdl_stream*)strm;

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

@@ -425 +425 @@
     unsigned i;
 
-    /* Allow shutdown() to be called multiple times as long as there is matching
-     * number of init().
+    /* Allow shutdown() to be called multiple times as long as there is
+     * matching number of init().
      */
     if (vid_subsys.init_count == 0) {
@@ -547 +547 @@
 
     for (drv_idx=0; drv_idx<vid_subsys.drv_cnt; ++drv_idx) {
-        if (!pj_ansi_stricmp(drv_name, vid_subsys.drv[drv_idx].name)) {
+        if (!pj_ansi_stricmp(drv_name, vid_subsys.drv[drv_idx].name))
+        {
             f = vid_subsys.drv[drv_idx].f;
             break;
@@ -556 +557 @@
         return PJ_ENOTFOUND;
 
-    for (dev_idx=0; dev_idx<vid_subsys.drv[drv_idx].dev_cnt; ++dev_idx) {
+    for (dev_idx=0; dev_idx<vid_subsys.drv[drv_idx].dev_cnt; ++dev_idx)
+    {
         pjmedia_vid_dev_info info;
         pj_status_t status;
@@ -607 +609 @@
 
 /* API: Open video stream object using the specified parameters. */
-PJ_DEF(pj_status_t) pjmedia_vid_stream_create(const pjmedia_vid_param *prm,
-                                              const pjmedia_vid_cb *cb,
-                                              void *user_data,
-                                              pjmedia_vid_stream **p_vid_strm)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_create(
+                                        const pjmedia_vid_param *prm,
+                                        const pjmedia_vid_cb *cb,
+                                        void *user_data,
+                                        pjmedia_vid_dev_stream **p_vid_strm)
 {
     pjmedia_vid_dev_factory *cap_f=NULL, *rend_f=NULL, *f=NULL;
@@ -675 +678 @@
 
 /* API: Get the running parameters for the specified video stream. */
-PJ_DEF(pj_status_t) pjmedia_vid_stream_get_param(pjmedia_vid_stream *strm,
-                                                 pjmedia_vid_param *param)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_get_param(
+                                            pjmedia_vid_dev_stream *strm,
+                                            pjmedia_vid_param *param)
 {
     pj_status_t status;
@@ -695 +699 @@
 
 /* API: Get the value of a specific capability of the video stream. */
-PJ_DEF(pj_status_t) pjmedia_vid_stream_get_cap(pjmedia_vid_stream *strm,
-                                               pjmedia_vid_dev_cap cap,
-                                               void *value)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_get_cap(
+                                            pjmedia_vid_dev_stream *strm,
+                                            pjmedia_vid_dev_cap cap,
+                                            void *value)
 {
     return strm->op->get_cap(strm, cap, value);
@@ -703 +708 @@
 
 /* API: Set the value of a specific capability of the video stream. */
-PJ_DEF(pj_status_t) pjmedia_vid_stream_set_cap(pjmedia_vid_stream *strm,
-                                               pjmedia_vid_dev_cap cap,
-                                               const void *value)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_set_cap(
+                                            pjmedia_vid_dev_stream *strm,
+                                            pjmedia_vid_dev_cap cap,
+                                            const void *value)
 {
     return strm->op->set_cap(strm, cap, value);
@@ -711 +717 @@
 
 /* API: Start the stream. */
-PJ_DEF(pj_status_t) pjmedia_vid_stream_start(pjmedia_vid_stream *strm)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_start(pjmedia_vid_dev_stream *strm)
 {
     return strm->op->start(strm);
 }
 
-PJ_DEF(pj_status_t) pjmedia_vid_stream_get_frame(pjmedia_vid_stream *strm,
-                                                 pjmedia_frame *frame)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_get_frame(
+                                            pjmedia_vid_dev_stream *strm,
+                                            pjmedia_frame *frame)
 {
     pj_assert(strm->op->get_frame);
@@ -723 +730 @@
 }
 
-PJ_DEF(pj_status_t) pjmedia_vid_stream_put_frame(pjmedia_vid_stream *strm,
-                                                 const pjmedia_frame *frame)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_put_frame(
+                                            pjmedia_vid_dev_stream *strm,
+                                            const pjmedia_frame *frame)
 {
     pj_assert(strm->op->put_frame);
@@ -731 +739 @@
 
 /* API: Stop the stream. */
-PJ_DEF(pj_status_t) pjmedia_vid_stream_stop(pjmedia_vid_stream *strm)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_stop(pjmedia_vid_dev_stream *strm)
 {
     return strm->op->stop(strm);
@@ -737 +745 @@
 
 /* API: Destroy the stream. */
-PJ_DEF(pj_status_t) pjmedia_vid_stream_destroy(pjmedia_vid_stream *strm)
+PJ_DEF(pj_status_t) pjmedia_vid_dev_stream_destroy(
+                                                pjmedia_vid_dev_stream *strm)
 {
     return strm->op->destroy(strm);

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

@@ -69 +69 @@
     pj_size_t       *content_len;       /**< frame length array             */
     pj_uint32_t     *bit_info;          /**< frame bit info array           */
+    pj_uint32_t     *ts;                /**< timestamp array                */
     
     /* States */
@@ -198 +199 @@
                                             sizeof(framelist->bit_info[0])*
                                             framelist->max_count);
-
+    framelist->ts           = (pj_uint32_t*)
+                              pj_pool_alloc(pool, 
+                                            sizeof(framelist->ts[0])*
+                                            framelist->max_count);
 
     return jb_framelist_reset(framelist);
@@ -259 +263 @@
                                   void *frame, pj_size_t *size,
                                   pjmedia_jb_frame_type *p_type,
-                                  pj_uint32_t *bit_info) 
+                                  pj_uint32_t *bit_info,
+                                  pj_uint32_t *ts) 
 {
     if (framelist->size) {
@@ -282 +287 @@
             if (bit_info)
                 *bit_info = framelist->bit_info[framelist->head];
+            if (ts)
+                *ts = framelist->ts[framelist->head];
 
             //pj_bzero(framelist->content + 
@@ -289 +296 @@
             framelist->content_len[framelist->head] = 0;
             framelist->bit_info[framelist->head] = 0;
+            framelist->ts[framelist->head] = 0;
 
             framelist->origin++;
@@ -302 +310 @@
 
     return PJ_FALSE;
+}
+
+
+static pj_bool_t jb_framelist_peek(jb_framelist_t *framelist,
+                                   unsigned idx,
+                                   const void **frame,
+                                   pj_size_t *size,
+                                   pjmedia_jb_frame_type *type,
+                                   pj_uint32_t *bit_info,
+                                   pj_uint32_t *ts) 
+{
+    unsigned pos;
+
+    if (idx >= jb_framelist_eff_size(framelist))
+        return PJ_FALSE;
+
+    pos = framelist->head;
+
+    /* Find actual peek position, note there may be discarded frames */
+    while (1) {
+        if (framelist->frame_type[pos] != PJMEDIA_JB_DISCARDED_FRAME) {
+            if (idx == 0)
+                break;
+            else
+                --idx;
+        }
+        pos = (pos + 1) % framelist->max_count;
+    }
+
+    /* Return the frame pointer */
+    if (frame)
+        *frame = framelist->content + pos*framelist->frame_size;
+    if (type)
+        *type = (pjmedia_jb_frame_type) 
+                framelist->frame_type[pos];
+    if (size)
+        *size = framelist->content_len[pos];
+    if (bit_info)
+        *bit_info = framelist->bit_info[pos];
+    if (ts)
+        *ts = framelist->ts[pos];
+
+    return PJ_TRUE;
 }
 
@@ -373 +424 @@
                                        unsigned frame_size,
                                        pj_uint32_t bit_info,
+                                       pj_uint32_t ts,
                                        unsigned frame_type)
 {
@@ -426 +478 @@
     framelist->content_len[pos] = frame_size;
     framelist->bit_info[pos] = bit_info;
+    framelist->ts[pos] = ts;
 
     /* update framelist size */
@@ -735 +788 @@
                                      int frame_seq)
 {
-    pjmedia_jbuf_put_frame2(jb, frame, frame_size, 0, frame_seq, NULL);
+    pjmedia_jbuf_put_frame3(jb, frame, frame_size, 0, frame_seq, 0, NULL);
 }
 
@@ -743 +796 @@
                                      pj_uint32_t bit_info,
                                      int frame_seq,
+                                     pj_bool_t *discarded)
+{
+    pjmedia_jbuf_put_frame3(jb, frame, frame_size, bit_info, frame_seq, 0, 
+                            discarded);
+}
+
+PJ_DEF(void) pjmedia_jbuf_put_frame3(pjmedia_jbuf *jb, 
+                                     const void *frame, 
+                                     pj_size_t frame_size, 
+                                     pj_uint32_t bit_info,
+                                     int frame_seq,
+                                     pj_uint32_t ts,
                                      pj_bool_t *discarded)
 {
@@ -812 +877 @@
     min_frame_size = PJ_MIN(frame_size, jb->jb_frame_size);
     status = jb_framelist_put_at(&jb->jb_framelist, frame_seq, frame,
-                                 min_frame_size, bit_info, frame_type);
+                                 min_frame_size, bit_info, ts, frame_type);
     
     /* Jitter buffer is full, remove some older frames */
@@ -835 +900 @@
         removed = jb_framelist_remove_head(&jb->jb_framelist, distance);
         status = jb_framelist_put_at(&jb->jb_framelist, frame_seq, frame,
-                                     min_frame_size, bit_info, frame_type);
+                                     min_frame_size, bit_info, ts, frame_type);
 
         jb->jb_discard += removed;
@@ -867 +932 @@
                                      char *p_frame_type)
 {
-    pjmedia_jbuf_get_frame2(jb, frame, NULL, p_frame_type, NULL);
+    pjmedia_jbuf_get_frame3(jb, frame, NULL, p_frame_type, NULL, NULL);
 }
 
@@ -879 +944 @@
                                      pj_uint32_t *bit_info)
 {
+    pjmedia_jbuf_get_frame3(jb, frame, size, p_frame_type, bit_info, NULL);
+}
+
+/*
+ * Get frame from jitter buffer.
+ */
+PJ_DEF(void) pjmedia_jbuf_get_frame3(pjmedia_jbuf *jb, 
+                                     void *frame, 
+                                     pj_size_t *size,
+                                     char *p_frame_type,
+                                     pj_uint32_t *bit_info,
+                                     pj_uint32_t *ts)
+{
     if (jb->jb_status == JB_STATUS_PREFETCHING) {
 
@@ -902 +980 @@
         /* Try to retrieve a frame from frame list */
         res = jb_framelist_get(&jb->jb_framelist, frame, size, &ftype, 
-                               bit_info);
+                               bit_info, ts);
         if (res) {
             /* We've successfully retrieved a frame from the frame list, but
@@ -970 +1048 @@
 }
 
+
+PJ_DEF(void) pjmedia_jbuf_peek_frame( pjmedia_jbuf *jb,
+                                      unsigned idx,
+                                      const void **frame, 
+                                      pj_size_t *size, 
+                                      char *p_frm_type,
+                                      pj_uint32_t *bit_info,
+                                      pj_uint32_t *ts)
+{
+    pjmedia_jb_frame_type ftype;
+    pj_bool_t res;
+
+    res = jb_framelist_peek(&jb->jb_framelist, idx, frame, size, &ftype, bit_info, ts);
+    if (!res)
+        *p_frm_type = PJMEDIA_JB_ZERO_EMPTY_FRAME;
+    else if (ftype == PJMEDIA_JB_NORMAL_FRAME)
+        *p_frm_type = PJMEDIA_JB_NORMAL_FRAME;
+    else
+        *p_frm_type = PJMEDIA_JB_MISSING_FRAME;
+}
+
+
+PJ_DEF(unsigned) pjmedia_jbuf_remove_frame(pjmedia_jbuf *jb, 
+                                           unsigned frame_cnt)
+{
+    unsigned count, last_discard_num;
+
+    last_discard_num = jb->jb_framelist.discarded_num;
+    count = jb_framelist_remove_head(&jb->jb_framelist, frame_cnt);
+
+    /* Remove some more when there were discarded frames included */
+    while (jb->jb_framelist.discarded_num < last_discard_num) {
+        /* Calculate frames count to be removed next */
+        frame_cnt = last_discard_num - jb->jb_framelist.discarded_num;
+
+        /* Normalize non-discarded frames count just been removed */
+        count -= frame_cnt;
+
+        /* Remove more frames */
+        last_discard_num = jb->jb_framelist.discarded_num;
+        count += jb_framelist_remove_head(&jb->jb_framelist, frame_cnt);
+    }
+
+    return count;
+}

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

@@ -23 +23 @@
 #include <pjmedia/rtcp.h>
 #include <pjmedia/jbuf.h>
+#include <pjmedia/stream_common.h>
 #include <pj/array.h>
 #include <pj/assert.h>
@@ -2739 +2740 @@
 }
 
+
+static const pj_str_t ID_AUDIO = { "audio", 5};
+static const pj_str_t ID_VIDEO = { "video", 5};
+static const pj_str_t ID_APPLICATION = { "application", 11};
+static const pj_str_t ID_IN = { "IN", 2 };
+static const pj_str_t ID_IP4 = { "IP4", 3};
+static const pj_str_t ID_IP6 = { "IP6", 3};
+static const pj_str_t ID_RTP_AVP = { "RTP/AVP", 7 };
+static const pj_str_t ID_RTP_SAVP = { "RTP/SAVP", 8 };
+//static const pj_str_t ID_SDP_NAME = { "pjmedia", 7 };
+static const pj_str_t ID_RTPMAP = { "rtpmap", 6 };
+static const pj_str_t ID_TELEPHONE_EVENT = { "telephone-event", 15 };
+
+static const pj_str_t STR_INACTIVE = { "inactive", 8 };
+static const pj_str_t STR_SENDRECV = { "sendrecv", 8 };
+static const pj_str_t STR_SENDONLY = { "sendonly", 8 };
+static const pj_str_t STR_RECVONLY = { "recvonly", 8 };
+
+
+/*
+ * Internal function for collecting codec info and param from the SDP media.
+ */
+static pj_status_t get_audio_codec_info_param(pjmedia_stream_info *si,
+                                              pj_pool_t *pool,
+                                              pjmedia_codec_mgr *mgr,
+                                              const pjmedia_sdp_media *local_m,
+                                              const pjmedia_sdp_media *rem_m)
+{
+    const pjmedia_sdp_attr *attr;
+    pjmedia_sdp_rtpmap *rtpmap;
+    unsigned i, fmti, pt = 0;
+    pj_status_t status;
+
+    /* Find the first codec which is not telephone-event */
+    for ( fmti = 0; fmti < local_m->desc.fmt_count; ++fmti ) {
+        if ( !pj_isdigit(*local_m->desc.fmt[fmti].ptr) )
+            return PJMEDIA_EINVALIDPT;
+        pt = pj_strtoul(&local_m->desc.fmt[fmti]);
+        if ( PJMEDIA_RTP_PT_TELEPHONE_EVENTS == 0 ||
+                pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS )
+                break;
+    }
+    if ( fmti >= local_m->desc.fmt_count )
+        return PJMEDIA_EINVALIDPT;
+
+    /* Get codec info.
+     * For static payload types, get the info from codec manager.
+     * For dynamic payload types, MUST get the rtpmap.
+     */
+    if (pt < 96) {
+        pj_bool_t has_rtpmap;
+
+        rtpmap = NULL;
+        has_rtpmap = PJ_TRUE;
+
+        attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP, 
+                                           &local_m->desc.fmt[fmti]);
+        if (attr == NULL) {
+            has_rtpmap = PJ_FALSE;
+        }
+        if (attr != NULL) {
+            status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
+            if (status != PJ_SUCCESS)
+                has_rtpmap = PJ_FALSE;
+        }
+
+        /* Build codec format info: */
+        if (has_rtpmap) {
+            si->fmt.type = si->type;
+            si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
+            pj_strdup(pool, &si->fmt.encoding_name, &rtpmap->enc_name);
+            si->fmt.clock_rate = rtpmap->clock_rate;
+            
+#if defined(PJMEDIA_HANDLE_G722_MPEG_BUG) && (PJMEDIA_HANDLE_G722_MPEG_BUG != 0)
+            /* The session info should have the actual clock rate, because 
+             * this info is used for calculationg buffer size, etc in stream 
+             */
+            if (si->fmt.pt == PJMEDIA_RTP_PT_G722)
+                si->fmt.clock_rate = 16000;
+#endif
+
+            /* For audio codecs, rtpmap parameters denotes the number of
+             * channels.
+             */
+            if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
+                si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
+            } else {
+                si->fmt.channel_cnt = 1;
+            }
+
+        } else {            
+            const pjmedia_codec_info *p_info;
+
+            status = pjmedia_codec_mgr_get_codec_info( mgr, pt, &p_info);
+            if (status != PJ_SUCCESS)
+                return status;
+
+            pj_memcpy(&si->fmt, p_info, sizeof(pjmedia_codec_info));
+        }
+
+        /* For static payload type, pt's are symetric */
+        si->tx_pt = pt;
+
+    } else {
+
+        attr = pjmedia_sdp_media_find_attr(local_m, &ID_RTPMAP, 
+                                           &local_m->desc.fmt[fmti]);
+        if (attr == NULL)
+            return PJMEDIA_EMISSINGRTPMAP;
+
+        status = pjmedia_sdp_attr_to_rtpmap(pool, attr, &rtpmap);
+        if (status != PJ_SUCCESS)
+            return status;
+
+        /* Build codec format info: */
+
+        si->fmt.type = si->type;
+        si->fmt.pt = pj_strtoul(&local_m->desc.fmt[fmti]);
+        pj_strdup(pool, &si->fmt.encoding_name, &rtpmap->enc_name);
+        si->fmt.clock_rate = rtpmap->clock_rate;
+
+        /* For audio codecs, rtpmap parameters denotes the number of
+         * channels.
+         */
+        if (si->type == PJMEDIA_TYPE_AUDIO && rtpmap->param.slen) {
+            si->fmt.channel_cnt = (unsigned) pj_strtoul(&rtpmap->param);
+        } else {
+            si->fmt.channel_cnt = 1;
+        }
+
+        /* Determine payload type for outgoing channel, by finding
+         * dynamic payload type in remote SDP that matches the answer.
+         */
+        si->tx_pt = 0xFFFF;
+        for (i=0; i<rem_m->desc.fmt_count; ++i) {
+            unsigned rpt;
+            pjmedia_sdp_attr *r_attr;
+            pjmedia_sdp_rtpmap r_rtpmap;
+
+            rpt = pj_strtoul(&rem_m->desc.fmt[i]);
+            if (rpt < 96)
+                continue;
+
+            r_attr = pjmedia_sdp_media_find_attr(rem_m, &ID_RTPMAP,
+                                                 &rem_m->desc.fmt[i]);
+            if (!r_attr)
+                continue;
+
+            if (pjmedia_sdp_attr_get_rtpmap(r_attr, &r_rtpmap) != PJ_SUCCESS)
+                continue;
+
+            if (!pj_stricmp(&rtpmap->enc_name, &r_rtpmap.enc_name) &&
+                rtpmap->clock_rate == r_rtpmap.clock_rate)
+            {
+                /* Found matched codec. */
+                si->tx_pt = rpt;
+
+                break;
+            }
+        }
+
+        if (si->tx_pt == 0xFFFF)
+            return PJMEDIA_EMISSINGRTPMAP;
+    }
+
+  
+    /* Now that we have codec info, get the codec param. */
+    si->param = PJ_POOL_ALLOC_T(pool, pjmedia_codec_param);
+    status = pjmedia_codec_mgr_get_default_param(mgr, &si->fmt,
+                                                 si->param);
+
+    /* Get remote fmtp for our encoder. */
+    pjmedia_stream_info_parse_fmtp(pool, rem_m, si->tx_pt,
+                                   &si->param->setting.enc_fmtp);
+
+    /* Get local fmtp for our decoder. */
+    pjmedia_stream_info_parse_fmtp(pool, local_m, si->fmt.pt, 
+                                   &si->param->setting.dec_fmtp);
+
+    /* Get the remote ptime for our encoder. */
+    attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
+                                  "ptime", NULL);
+    if (attr) {
+        pj_str_t tmp_val = attr->value;
+        unsigned frm_per_pkt;
+ 
+        pj_strltrim(&tmp_val);
+
+        /* Round up ptime when the specified is not multiple of frm_ptime */
+        frm_per_pkt = (pj_strtoul(&tmp_val) + 
+                      si->param->info.frm_ptime/2) /
+                      si->param->info.frm_ptime;
+        if (frm_per_pkt != 0) {
+            si->param->setting.frm_per_pkt = (pj_uint8_t)frm_per_pkt;
+        }
+    }
+
+    /* Get remote maxptime for our encoder. */
+    attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
+                                  "maxptime", NULL);
+    if (attr) {
+        pj_str_t tmp_val = attr->value;
+
+        pj_strltrim(&tmp_val);
+        si->tx_maxptime = pj_strtoul(&tmp_val);
+    }
+
+    /* When direction is NONE (it means SDP negotiation has failed) we don't
+     * need to return a failure here, as returning failure will cause
+     * the whole SDP to be rejected. See ticket #:
+     *  http://
+     *
+     * Thanks Alain Totouom 
+     */
+    if (status != PJ_SUCCESS && si->dir != PJMEDIA_DIR_NONE)
+        return status;
+
+
+    /* Get incomming payload type for telephone-events */
+    si->rx_event_pt = -1;
+    for (i=0; i<local_m->attr_count; ++i) {
+        pjmedia_sdp_rtpmap r;
+
+        attr = local_m->attr[i];
+        if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
+            continue;
+        if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
+            continue;
+        if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
+            si->rx_event_pt = pj_strtoul(&r.pt);
+            break;
+        }
+    }
+
+    /* Get outgoing payload type for telephone-events */
+    si->tx_event_pt = -1;
+    for (i=0; i<rem_m->attr_count; ++i) {
+        pjmedia_sdp_rtpmap r;
+
+        attr = rem_m->attr[i];
+        if (pj_strcmp(&attr->name, &ID_RTPMAP) != 0)
+            continue;
+        if (pjmedia_sdp_attr_get_rtpmap(attr, &r) != PJ_SUCCESS)
+            continue;
+        if (pj_strcmp(&r.enc_name, &ID_TELEPHONE_EVENT) == 0) {
+            si->tx_event_pt = pj_strtoul(&r.pt);
+            break;
+        }
+    }
+
+    return PJ_SUCCESS;
+}
+
+
+
+/*
+ * Create stream info from SDP media line.
+ */
+PJ_DEF(pj_status_t) pjmedia_stream_info_from_sdp(
+                                           pjmedia_stream_info *si,
+                                           pj_pool_t *pool,
+                                           pjmedia_endpt *endpt,
+                                           const pjmedia_sdp_session *local,
+                                           const pjmedia_sdp_session *remote,
+                                           unsigned stream_idx)
+{
+    pjmedia_codec_mgr *mgr;
+    const pjmedia_sdp_attr *attr;
+    const pjmedia_sdp_media *local_m;
+    const pjmedia_sdp_media *rem_m;
+    const pjmedia_sdp_conn *local_conn;
+    const pjmedia_sdp_conn *rem_conn;
+    int rem_af, local_af;
+    pj_sockaddr local_addr;
+    pj_status_t status;
+
+    
+    /* Validate arguments: */
+    PJ_ASSERT_RETURN(pool && si && local && remote, PJ_EINVAL);
+    PJ_ASSERT_RETURN(stream_idx < local->media_count, PJ_EINVAL);
+    PJ_ASSERT_RETURN(stream_idx < remote->media_count, PJ_EINVAL);
+
+    /* Keep SDP shortcuts */
+    local_m = local->media[stream_idx];
+    rem_m = remote->media[stream_idx];
+
+    local_conn = local_m->conn ? local_m->conn : local->conn;
+    if (local_conn == NULL)
+        return PJMEDIA_SDP_EMISSINGCONN;
+
+    rem_conn = rem_m->conn ? rem_m->conn : remote->conn;
+    if (rem_conn == NULL)
+        return PJMEDIA_SDP_EMISSINGCONN;
+
+    /* Media type must be audio */
+    if (pj_stricmp(&local_m->desc.media, &ID_AUDIO) == 0)
+        return PJMEDIA_EINVALIMEDIATYPE;
+
+    /* Get codec manager. */
+    mgr = pjmedia_endpt_get_codec_mgr(endpt);
+
+    /* Reset: */
+
+    pj_bzero(si, sizeof(*si));
+
+#if PJMEDIA_HAS_RTCP_XR && PJMEDIA_STREAM_ENABLE_XR
+    /* Set default RTCP XR enabled/disabled */
+    si->rtcp_xr_enabled = PJ_TRUE;
+#endif
+
+    /* Media type: */
+    si->type = PJMEDIA_TYPE_AUDIO;
+
+    /* Transport protocol */
+
+    /* At this point, transport type must be compatible, 
+     * the transport instance will do more validation later.
+     */
+    status = pjmedia_sdp_transport_cmp(&rem_m->desc.transport, 
+                                       &local_m->desc.transport);
+    if (status != PJ_SUCCESS)
+        return PJMEDIA_SDPNEG_EINVANSTP;
+
+    if (pj_stricmp(&local_m->desc.transport, &ID_RTP_AVP) == 0) {
+
+        si->proto = PJMEDIA_TP_PROTO_RTP_AVP;
+
+    } else if (pj_stricmp(&local_m->desc.transport, &ID_RTP_SAVP) == 0) {
+
+        si->proto = PJMEDIA_TP_PROTO_RTP_SAVP;
+
+    } else {
+
+        si->proto = PJMEDIA_TP_PROTO_UNKNOWN;
+        return PJ_SUCCESS;
+    }
+
+
+    /* Check address family in remote SDP */
+    rem_af = pj_AF_UNSPEC();
+    if (pj_stricmp(&rem_conn->net_type, &ID_IN)==0) {
+        if (pj_stricmp(&rem_conn->addr_type, &ID_IP4)==0) {
+            rem_af = pj_AF_INET();
+        } else if (pj_stricmp(&rem_conn->addr_type, &ID_IP6)==0) {
+            rem_af = pj_AF_INET6();
+        }
+    }
+
+    if (rem_af==pj_AF_UNSPEC()) {
+        /* Unsupported address family */
+        return PJ_EAFNOTSUP;
+    }
+
+    /* Set remote address: */
+    status = pj_sockaddr_init(rem_af, &si->rem_addr, &rem_conn->addr, 
+                              rem_m->desc.port);
+    if (status != PJ_SUCCESS) {
+        /* Invalid IP address. */
+        return PJMEDIA_EINVALIDIP;
+    }
+
+    /* Check address family of local info */
+    local_af = pj_AF_UNSPEC();
+    if (pj_stricmp(&local_conn->net_type, &ID_IN)==0) {
+        if (pj_stricmp(&local_conn->addr_type, &ID_IP4)==0) {
+            local_af = pj_AF_INET();
+        } else if (pj_stricmp(&local_conn->addr_type, &ID_IP6)==0) {
+            local_af = pj_AF_INET6();
+        }
+    }
+
+    if (local_af==pj_AF_UNSPEC()) {
+        /* Unsupported address family */
+        return PJ_SUCCESS;
+    }
+
+    /* Set remote address: */
+    status = pj_sockaddr_init(local_af, &local_addr, &local_conn->addr, 
+                              local_m->desc.port);
+    if (status != PJ_SUCCESS) {
+        /* Invalid IP address. */
+        return PJMEDIA_EINVALIDIP;
+    }
+
+    /* Local and remote address family must match */
+    if (local_af != rem_af)
+        return PJ_EAFNOTSUP;
+
+    /* Media direction: */
+
+    if (local_m->desc.port == 0 || 
+        pj_sockaddr_has_addr(&local_addr)==PJ_FALSE ||
+        pj_sockaddr_has_addr(&si->rem_addr)==PJ_FALSE ||
+        pjmedia_sdp_media_find_attr(local_m, &STR_INACTIVE, NULL)!=NULL)
+    {
+        /* Inactive stream. */
+
+        si->dir = PJMEDIA_DIR_NONE;
+
+    } else if (pjmedia_sdp_media_find_attr(local_m, &STR_SENDONLY, NULL)!=NULL) {
+
+        /* Send only stream. */
+
+        si->dir = PJMEDIA_DIR_ENCODING;
+
+    } else if (pjmedia_sdp_media_find_attr(local_m, &STR_RECVONLY, NULL)!=NULL) {
+
+        /* Recv only stream. */
+
+        si->dir = PJMEDIA_DIR_DECODING;
+
+    } else {
+
+        /* Send and receive stream. */
+
+        si->dir = PJMEDIA_DIR_ENCODING_DECODING;
+
+    }
+
+    /* No need to do anything else if stream is rejected */
+    if (local_m->desc.port == 0) {
+        return PJ_SUCCESS;
+    }
+
+    /* If "rtcp" attribute is present in the SDP, set the RTCP address
+     * from that attribute. Otherwise, calculate from RTP address.
+     */
+    attr = pjmedia_sdp_attr_find2(rem_m->attr_count, rem_m->attr,
+                                  "rtcp", NULL);
+    if (attr) {
+        pjmedia_sdp_rtcp_attr rtcp;
+        status = pjmedia_sdp_attr_get_rtcp(attr, &rtcp);
+        if (status == PJ_SUCCESS) {
+            if (rtcp.addr.slen) {
+                status = pj_sockaddr_init(rem_af, &si->rem_rtcp, &rtcp.addr,
+                                          (pj_uint16_t)rtcp.port);
+            } else {
+                pj_sockaddr_init(rem_af, &si->rem_rtcp, NULL, 
+                                 (pj_uint16_t)rtcp.port);
+                pj_memcpy(pj_sockaddr_get_addr(&si->rem_rtcp),
+                          pj_sockaddr_get_addr(&si->rem_addr),
+                          pj_sockaddr_get_addr_len(&si->rem_addr));
+            }
+        }
+    }
+    
+    if (!pj_sockaddr_has_addr(&si->rem_rtcp)) {
+        int rtcp_port;
+
+        pj_memcpy(&si->rem_rtcp, &si->rem_addr, sizeof(pj_sockaddr));
+        rtcp_port = pj_sockaddr_get_port(&si->rem_addr) + 1;
+        pj_sockaddr_set_port(&si->rem_rtcp, (pj_uint16_t)rtcp_port);
+    }
+
+
+    /* Get the payload number for receive channel. */
+    /*
+       Previously we used to rely on fmt[0] being the selected codec,
+       but some UA sends telephone-event as fmt[0] and this would
+       cause assert failure below.
+
+       Thanks Chris Hamilton <chamilton .at. cs.dal.ca> for this patch.
+
+    // And codec must be numeric!
+    if (!pj_isdigit(*local_m->desc.fmt[0].ptr) || 
+        !pj_isdigit(*rem_m->desc.fmt[0].ptr))
+    {
+        return PJMEDIA_EINVALIDPT;
+    }
+
+    pt = pj_strtoul(&local_m->desc.fmt[0]);
+    pj_assert(PJMEDIA_RTP_PT_TELEPHONE_EVENTS==0 ||
+              pt != PJMEDIA_RTP_PT_TELEPHONE_EVENTS);
+    */
+
+    /* Get codec info and param */
+    status = get_audio_codec_info_param(si, pool, mgr, local_m, rem_m);
+
+    /* Leave SSRC to random. */
+    si->ssrc = pj_rand();
+
+    /* Set default jitter buffer parameter. */
+    si->jb_init = si->jb_max = si->jb_min_pre = si->jb_max_pre = -1;
+
+    return status;
+}

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

@@ -29 +29 @@
 static pjmedia_vid_codec_mgr *def_vid_codec_mgr;
 
-/* Definition of default codecs parameters */
-struct pjmedia_vid_codec_default_param
-{
-    pjmedia_vid_codec_param     *param;
+
+/*
+ * Codec manager maintains array of these structs for each supported
+ * codec.
+ */
+typedef struct pjmedia_vid_codec_desc
+{
+    pjmedia_vid_codec_info           info;      /**< Codec info.            */
+    pjmedia_codec_id                 id;        /**< Fully qualified name   */
+    pjmedia_codec_priority           prio;      /**< Priority.              */
+    pjmedia_vid_codec_factory       *factory;   /**< The factory.           */
+    pjmedia_vid_codec_param         *def_param; /**< Default codecs 
+                                                     parameters.            */
+} pjmedia_vid_codec_desc;
+
+
+/* The declaration of video codec manager */
+struct pjmedia_vid_codec_mgr
+{
+    /** Codec manager mutex. */
+    pj_mutex_t                  *mutex;
+
+    /** List of codec factories registered to codec manager. */
+    pjmedia_vid_codec_factory    factory_list;
+
+    /** Number of supported codecs. */
+    unsigned                     codec_cnt;
+
+    /** Array of codec descriptor. */
+    pjmedia_vid_codec_desc       codec_desc[PJMEDIA_CODEC_MGR_MAX_CODECS];
+
 };
+
 
 
@@ -94 +122 @@
 PJ_DEF(pjmedia_vid_codec_mgr*) pjmedia_vid_codec_mgr_instance(void)
 {
-    pj_assert(def_vid_codec_mgr);
+    //pj_assert(def_vid_codec_mgr);
     return def_vid_codec_mgr;
 }
@@ -616 +644 @@
                   &param->dec_fmtp.param[i].val);
     }
-    for (i = 0; i < param->dec_fmtp.cnt; ++i) {
-        pj_strdup(pool, &p->dec_fmtp.param[i].name, 
-                  &param->dec_fmtp.param[i].name);
-        pj_strdup(pool, &p->dec_fmtp.param[i].val, 
-                  &param->dec_fmtp.param[i].val);
+    for (i = 0; i < param->enc_fmtp.cnt; ++i) {
+        pj_strdup(pool, &p->enc_fmtp.param[i].name, 
+                  &param->enc_fmtp.param[i].name);
+        pj_strdup(pool, &p->enc_fmtp.param[i].val, 
+                  &param->enc_fmtp.param[i].val);
     }
 

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

@@ -38 +38 @@
     pjmedia_dir          dir;
     pjmedia_rect_size    cap_size;
-    pjmedia_vid_stream  *strm;
+    pjmedia_vid_dev_stream      *strm;
     pjmedia_vid_cb       strm_cb;
     void                *strm_cb_data;
@@ -75 +75 @@
 };
 
-static pj_status_t vidstream_cap_cb(pjmedia_vid_stream *stream,
+static pj_status_t vidstream_cap_cb(pjmedia_vid_dev_stream *stream,
                                     void *user_data,
                                     pjmedia_frame *frame);
-static pj_status_t vidstream_render_cb(pjmedia_vid_stream *stream,
+static pj_status_t vidstream_render_cb(pjmedia_vid_dev_stream *stream,
                                        void *user_data,
                                        pjmedia_frame *frame);
-static pj_status_t vidstream_event_cb(pjmedia_vid_stream *stream,
+static pj_status_t vidstream_event_cb(pjmedia_vid_dev_stream *stream,
                                       void *user_data,
                                       pjmedia_vid_event *event);
@@ -171 +171 @@
     vid_cb.on_event_cb = &vidstream_event_cb;
 
-    status = pjmedia_vid_stream_create(&prm->vidparam, &vid_cb, vp,
-                                       &vp->strm);
+    status = pjmedia_vid_dev_stream_create(&prm->vidparam, &vid_cb, vp,
+                                           &vp->strm);
     if (status != PJ_SUCCESS)
         goto on_error;
@@ -278 +278 @@
 }
 
-PJ_DEF(pjmedia_vid_stream*)
+PJ_DEF(pjmedia_vid_dev_stream*)
 pjmedia_vid_port_get_stream(pjmedia_vid_port *vp)
 {
@@ -357 +357 @@
     PJ_ASSERT_RETURN(vp, PJ_EINVAL);
 
-    status = pjmedia_vid_stream_start(vp->strm);
+    status = pjmedia_vid_dev_stream_start(vp->strm);
     if (status != PJ_SUCCESS)
         goto on_error;
@@ -386 +386 @@
     PJ_ASSERT_RETURN(vp, PJ_EINVAL);
 
-    status = pjmedia_vid_stream_stop(vp->strm);
+    status = pjmedia_vid_dev_stream_stop(vp->strm);
 
     if (vp->enc_clock) {
@@ -414 +414 @@
     }
     if (vp->strm) {
-        pjmedia_vid_stream_destroy(vp->strm);
+        pjmedia_vid_dev_stream_destroy(vp->strm);
         vp->strm = NULL;
     }
@@ -478 +478 @@
         return;
 
-    status = pjmedia_vid_stream_get_frame(vp->strm, vp->enc_frm_buf);
+    status = pjmedia_vid_dev_stream_get_frame(vp->strm, vp->enc_frm_buf);
     if (status != PJ_SUCCESS)
         return;
@@ -581 +581 @@
                 } else
                     vp->rend_sync_clocksrc.nsync_progress += ndrop;
+
                 for (i = 0; i < ndrop; i++) {
                     status = pjmedia_port_get_frame(vp->client_port,
@@ -603 +604 @@
     pjmedia_clock_src_update(&vp->rend_clocksrc, NULL);
 
-    status = pjmedia_vid_stream_put_frame(vp->strm, vp->dec_frm_buf);
+    status = pjmedia_vid_dev_stream_put_frame(vp->strm, vp->dec_frm_buf);
 }
 
@@ -615 +616 @@
 }
 
-static pj_status_t vidstream_cap_cb(pjmedia_vid_stream *stream,
+static pj_status_t vidstream_cap_cb(pjmedia_vid_dev_stream *stream,
                                     void *user_data,
                                     pjmedia_frame *frame)
@@ -634 +635 @@
 }
 
-static pj_status_t vidstream_render_cb(pjmedia_vid_stream *stream,
+static pj_status_t vidstream_render_cb(pjmedia_vid_dev_stream *stream,
                                        void *user_data,
                                        pjmedia_frame *frame)
@@ -653 +654 @@
 }
 
-static pj_status_t vidstream_event_cb(pjmedia_vid_stream *stream,
+static pj_status_t vidstream_event_cb(pjmedia_vid_dev_stream *stream,
                                       void *user_data,
                                       pjmedia_vid_event *event)
@@ -671 +672 @@
 
     if (vp->stream_role==ROLE_PASSIVE) {
-        return pjmedia_vid_stream_put_frame(vp->strm, frame);
+        return pjmedia_vid_dev_stream_put_frame(vp->strm, frame);
     } else {
         pj_mutex_lock(vp->dec_frm_mutex);
@@ -688 +689 @@
 
     if (vp->stream_role==ROLE_PASSIVE) {
-        return pjmedia_vid_stream_get_frame(vp->strm, frame);
+        return pjmedia_vid_dev_stream_get_frame(vp->strm, frame);
     } else {
         pj_mutex_lock(vp->enc_frm_mutex);