codec improvement

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@114 d0543943-73ff-0310-b7d9-9358b9ac24b2

diff --git a/src/include/switch_frame.h b/src/include/switch_frame.h
index 39843593a51e4cd1a349731a69c5c14c1390c1cc..354bbd0ea56d339b28c2f9031fde9039dc67d92a 100644 (file)
--- a/src/include/switch_frame.h
+++ b/src/include/switch_frame.h
@@ -42,6 +42,7 @@ struct switch_frame {
        switch_codec *codec;
        void *data;
        size_t datalen;
+       size_t buflen;
        int samples;
 };
 

diff --git a/src/mod/mod_codec_g729/mod_codec_g729.c b/src/mod/mod_codec_g729/mod_codec_g729.c
index 3181048619ef4188203da2dc63def58b10bc9fed..aa598f06734ee5c41caf34dadfe16d0666181283 100644 (file)
--- a/src/mod/mod_codec_g729/mod_codec_g729.c
+++ b/src/mod/mod_codec_g729/mod_codec_g729.c
@@ -84,11 +84,26 @@ static switch_status switch_g729_encode(switch_codec *codec,
        if (!context) {\r
                return SWITCH_STATUS_FALSE;\r
        }\r
-\r
-       g729_coder(&context->encoder_object, (short *) decoded_data,  encoded_data, &cbret);\r
-       \r
-       *encoded_data_len = codec->implementation->encoded_bytes_per_frame;\r
-\r
+       if (decoded_data_len % 160 == 0) {\r
+               unsigned int new_len = 0;\r
+               INT16 *ddp = decoded_data;\r
+               char *edp = encoded_data;\r
+               int x;\r
+               int loops = (int) decoded_data_len / 160;\r
+               \r
+               for(x = 0; x < loops && new_len < *encoded_data_len; x++) {\r
+                       g729_coder(&context->encoder_object, ddp, edp, &cbret);\r
+                       edp += 10;\r
+                       ddp += 80;\r
+                       new_len += 10;\r
+               }\r
+               if( new_len <= *encoded_data_len ) {\r
+                       *encoded_data_len = new_len;\r
+               } else {\r
+                       switch_console_printf(SWITCH_CHANNEL_CONSOLE, "buffer overflow!!! %u >= %u\n", new_len, *encoded_data_len);\r
+                       return SWITCH_STATUS_FALSE;                     \r
+               }\r
+       }\r
        return SWITCH_STATUS_SUCCESS;\r
 }\r
 \r
@@ -102,21 +117,35 @@ static switch_status switch_g729_decode(switch_codec *codec,
                                                                   unsigned int *flag) \r
 {\r
        struct g729_context *context = codec->private;\r
-       short *dbuf;\r
-       unsigned char *ebuf;\r
-\r
+       \r
        if (!context) {\r
                return SWITCH_STATUS_FALSE;\r
        }\r
 \r
-       if (*flag & SWITCH_CODEC_FLAG_SILENCE) {\r
-               memset(dbuf, 0, codec->implementation->bytes_per_frame);\r
-               *decoded_data_len = codec->implementation->bytes_per_frame;\r
+\r
+       if (encoded_data_len % 10 == 0) {\r
+               int loops = (int) encoded_data_len / 10;\r
+               char *edp = encoded_data;\r
+               short *ddp = decoded_data;\r
+               int x;\r
+               unsigned int new_len = 0;\r
+               for(x = 0; x < loops && new_len < *decoded_data_len; x++) {\r
+                       g729_decoder(&context->decoder_object, ddp, edp, 10);\r
+                       ddp += 80;\r
+                       edp += 10;\r
+                       new_len += 160;\r
+               }\r
+               if (new_len <= *decoded_data_len) {\r
+                       *decoded_data_len = new_len;\r
+               } else {\r
+                       switch_console_printf(SWITCH_CHANNEL_CONSOLE, "buffer overflow!!!\n");\r
+                       return SWITCH_STATUS_FALSE;\r
+               }\r
        } else {\r
-               g729_decoder(&context->decoder_object, decoded_data, encoded_data, encoded_data_len);\r
-               *decoded_data_len = codec->implementation->bytes_per_frame;\r
+               switch_console_printf(SWITCH_CHANNEL_CONSOLE, "yo this frame is an odd size [%d]\n", encoded_data_len);\r
        }\r
-\r
+       \r
+       \r
        return SWITCH_STATUS_SUCCESS;\r
 }\r
 \r
@@ -130,7 +159,7 @@ static const switch_codec_implementation g729_8k_implementation = {
        /*.bytes_per_frame*/                            320,\r
        /*.encoded_bytes_per_frame*/            20,\r
        /*.number_of_channels*/                         1,\r
-       /*.pref_frames_per_packet*/                     6,\r
+       /*.pref_frames_per_packet*/                     1,\r
        /*.max_frames_per_packet*/                      24,\r
        /*.init*/                                                       switch_g729_init,\r
        /*.encode*/                                                     switch_g729_encode,\r

diff --git a/src/mod/mod_exosip/mod_exosip.c b/src/mod/mod_exosip/mod_exosip.c
index 07bda55065d91376666f9da9881886e6a1294f0d..bcc5f07a25523996bba9cc7060df3af635e28cee 100644 (file)
--- a/src/mod/mod_exosip/mod_exosip.c
+++ b/src/mod/mod_exosip/mod_exosip.c
@@ -225,6 +225,7 @@ static switch_status exosip_on_init(switch_core_session *session)
        assert(tech_pvt != NULL);
 
        tech_pvt->read_frame.data = tech_pvt->read_buf;
+       tech_pvt->read_frame.buflen = sizeof(tech_pvt->read_buf);
 
        switch_console_printf(SWITCH_CHANNEL_CONSOLE, "EXOSIP INIT\n");
 

diff --git a/src/mod/mod_iaxchan/mod_iaxchan.c b/src/mod/mod_iaxchan/mod_iaxchan.c
index 6f91ffd1b9a61a0e87357466c1a14a099145be14..71a757e445303a2adbe75d7604eec5fd15777206 100644 (file)
--- a/src/mod/mod_iaxchan/mod_iaxchan.c
+++ b/src/mod/mod_iaxchan/mod_iaxchan.c
@@ -354,7 +354,7 @@ static switch_status channel_on_init(switch_core_session *session)
        assert(channel != NULL);
 
        tech_pvt->read_frame.data = tech_pvt->databuf;
-
+       tech_pvt->read_frame.buflen = sizeof(tech_pvt->databuf);
        iax_set_private(tech_pvt->iax_session, tech_pvt);
 
        switch_set_flag(tech_pvt, TFLAG_IO);
@@ -631,7 +631,6 @@ static switch_status channel_write_frame(switch_core_session *session, switch_fr
        if (switch_test_flag(tech_pvt, TFLAG_LINEAR)) {
                switch_swap_linear(frame->data, (int)frame->datalen / 2);
        }
-       
        iax_send_voice(tech_pvt->iax_session, tech_pvt->codec, frame->data, (int)frame->datalen, tech_pvt->write_codec.implementation->samples_per_frame);
 
        return SWITCH_STATUS_SUCCESS;

diff --git a/src/mod/mod_playback/mod_playback.c b/src/mod/mod_playback/mod_playback.c
index b5220043e8ab5d7d9b7c1a541b6e38e4d11a7b7a..02dc03b793c9766f9e77b85cbac79cf76c297bb3 100644 (file)
--- a/src/mod/mod_playback/mod_playback.c
+++ b/src/mod/mod_playback/mod_playback.c
@@ -58,7 +58,7 @@ void playback_function(switch_core_session *session, char *data)
        switch_channel_answer(channel);
 
        write_frame.data = buf;
-
+       write_frame.buflen = sizeof(buf);
 
        if (switch_file_open(&fd, data, SWITCH_FOPEN_READ, SWITCH_FPROT_UREAD, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                switch_console_printf(SWITCH_CHANNEL_CONSOLE, "OPEN FILE FAILED\n");

diff --git a/src/mod/mod_portaudio/mod_portaudio.c b/src/mod/mod_portaudio/mod_portaudio.c
index da0eb4cf16d6382ea6fc741bbdfab5ccb1293acf..d6593059497e367cd21a8062675372d4bc041db6 100644 (file)
--- a/src/mod/mod_portaudio/mod_portaudio.c
+++ b/src/mod/mod_portaudio/mod_portaudio.c
@@ -129,6 +129,7 @@ static switch_status channel_on_init(switch_core_session *session)
        assert(channel != NULL);
 
        tech_pvt->read_frame.data = tech_pvt->databuf;
+       tech_pvt->read_frame.buflen = sizeof(tech_pvt->databuf);
 
        switch_set_flag(tech_pvt, TFLAG_IO);
        
@@ -361,6 +362,7 @@ static switch_status channel_write_frame(switch_core_session *session, switch_fr
        }
 */
        
+
        WriteAudioStream(tech_pvt->audio_out, (short *)frame->data, (int)(frame->datalen / sizeof(SAMPLE)));
        //XXX send voice
 

diff --git a/src/switch_core.c b/src/switch_core.c
index a4197a0b6724cbc16d675f4be98f48f285f7e1d2..0a62a795c97fb998a2ec6f6bc8c7365e2f590748 100644 (file)
--- a/src/switch_core.c
+++ b/src/switch_core.c
@@ -523,6 +523,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session
 
                if (read_frame->codec) {
                        size_t flag = 0;
+                       session->raw_read_frame.datalen = session->raw_read_frame.buflen;
                        status = switch_core_codec_decode(read_frame->codec,
                                                                                   session->read_codec,
                                                                                   read_frame->data,
@@ -549,7 +550,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session
                        if ((*frame)->datalen == session->read_codec->implementation->bytes_per_frame) {
                                perfect = TRUE;
                        } else {
-                               if (! session->raw_write_buffer) {
+                               if (! session->raw_read_buffer) {
                                        int bytes = session->read_codec->implementation->bytes_per_frame * 10;
                                        switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Engaging Read Buffer at %d bytes\n", bytes);
                                        switch_buffer_create(session->pool, &session->raw_read_buffer, bytes);
@@ -570,7 +571,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_read_frame(switch_core_session
                                                                                                                                                                  session->read_codec->implementation->bytes_per_frame);
                                        enc_frame = &session->raw_read_frame;
                                }
-
+                               session->enc_read_frame.datalen = session->enc_read_frame.buflen;
                                status = switch_core_codec_encode(session->read_codec,
                                                                                           (*frame)->codec,
                                                                                           session->raw_read_frame.data,
@@ -641,6 +642,8 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio
 
        if (need_codec) {
                if (frame->codec) {
+
+                       session->raw_write_frame.datalen = session->raw_write_frame.buflen;
                        status = switch_core_codec_decode(frame->codec,
                                                                                   session->write_codec,
                                                                                   frame->data,
@@ -687,6 +690,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio
 
                        if (perfect) {
                                enc_frame = write_frame;
+                               session->enc_write_frame.datalen = session->enc_write_frame.buflen;
                                status = switch_core_codec_encode(session->write_codec,
                                                                                           frame->codec,
                                                                                           enc_frame->data,
@@ -728,6 +732,7 @@ SWITCH_DECLARE(switch_status) switch_core_session_write_frame(switch_core_sessio
                                                                                         bytes))) {
 
                                                        enc_frame = &session->raw_write_frame;
+                                                       session->enc_write_frame.datalen = session->enc_write_frame.buflen;
                                                        status = switch_core_codec_encode(session->write_codec,
                                                                                                                   frame->codec,
                                                                                                                   enc_frame->data,
@@ -1447,10 +1452,15 @@ SWITCH_DECLARE(switch_core_session *) switch_core_session_request(const switch_e
        session->endpoint_interface = endpoint_interface;
 
        session->raw_write_frame.data = session->raw_write_buf;
+       session->raw_write_frame.buflen = sizeof(session->raw_write_buf);
        session->raw_read_frame.data = session->raw_read_buf;
+       session->raw_read_frame.buflen = sizeof(session->raw_read_buf);
+       
 
        session->enc_write_frame.data = session->enc_write_buf;
+       session->enc_write_frame.buflen = sizeof(session->enc_write_buf);
        session->enc_read_frame.data = session->enc_read_buf;
+       session->enc_read_frame.buflen = sizeof(session->enc_read_buf);
 
        switch_mutex_init(&session->mutex, SWITCH_MUTEX_NESTED ,session->pool);
        switch_thread_cond_create(&session->cond, session->pool);