gnash-commit
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Gnash-commit] gnash ChangeLog backend/sound_handler_sdl.cpp [release_0_


From: Tomas Groth
Subject: [Gnash-commit] gnash ChangeLog backend/sound_handler_sdl.cpp [release_0_7_2]
Date: Mon, 06 Nov 2006 23:47:55 +0000

CVSROOT:        /sources/gnash
Module name:    gnash
Branch:         release_0_7_2
Changes by:     Tomas Groth <tgc>       06/11/06 23:47:55

Modified files:
        .              : ChangeLog 
        backend        : sound_handler_sdl.cpp 

Log message:
        Added some asserts, and some 0-index fixes.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/gnash/ChangeLog?cvsroot=gnash&only_with_tag=release_0_7_2&r1=1.1412.2.101&r2=1.1412.2.102
http://cvs.savannah.gnu.org/viewcvs/gnash/backend/sound_handler_sdl.cpp?cvsroot=gnash&only_with_tag=release_0_7_2&r1=1.29.2.4&r2=1.29.2.5

Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/gnash/gnash/ChangeLog,v
retrieving revision 1.1412.2.101
retrieving revision 1.1412.2.102
diff -u -b -r1.1412.2.101 -r1.1412.2.102
--- ChangeLog   6 Nov 2006 21:03:23 -0000       1.1412.2.101
+++ ChangeLog   6 Nov 2006 23:47:55 -0000       1.1412.2.102
@@ -1,8 +1,9 @@
-2006-11-06 Tomas Groth Christensen <tomas@>
+2006-11-06 Tomas Groth Christensen <address@hidden>
 
        * backend/sound_handler_sdl.cpp: Make mp3-decoding with mad work
          when the stream is not fully loaded when playback starts. Fixes
          bug #18207.
+         Added some asserts, and some 0-index fixes.
 
 2006-11-06  Rob Savoye  <address@hidden>
 

Index: backend/sound_handler_sdl.cpp
===================================================================
RCS file: /sources/gnash/gnash/backend/sound_handler_sdl.cpp,v
retrieving revision 1.29.2.4
retrieving revision 1.29.2.5
diff -u -b -r1.29.2.4 -r1.29.2.5
--- backend/sound_handler_sdl.cpp       6 Nov 2006 21:03:24 -0000       1.29.2.4
+++ backend/sound_handler_sdl.cpp       6 Nov 2006 23:47:55 -0000       1.29.2.5
@@ -658,7 +658,7 @@
        pthread_mutex_lock(&handler->mutex);
 
        // Mixed sounddata buffer
-       Uint8* buffer = stream;  //new Uint8[len];
+       Uint8* buffer = stream;
        memset(buffer, 0, buffer_length);
 
        for(uint32_t i=0; i < handler->m_sound_data.size(); i++) {
@@ -671,22 +671,26 @@
                        // mix some more until the buffer is full. If a sound 
loops the magic
                        // happens here ;)
                        if (sound->raw_data_size - sound->raw_position < 
buffer_length 
-                               && (sound->position < sound->data_size || 
sound->loop_count != 0)) {
+                               && (sound->position+1 < sound->data_size || 
sound->loop_count != 0)) {
 
                                // First we mix what is decoded
                                unsigned int index = 0;
-                               if (sound->raw_data_size - sound->raw_position 
> 0) {
+                               if (sound->raw_data_size - sound->raw_position 
> 1) {
                                        // If the volume needs adjustments we 
call a function to do that
                                        if (handler->m_sound_data[i]->volume != 
100) {
                                                
adjust_volume((int16_t*)(sound->raw_data + sound->raw_position), 
-                                                       sound->raw_data_size - 
sound->raw_position,
+                                                       sound->raw_data_size-1 
- sound->raw_position,
                                                        
handler->m_sound_data[i]->volume);
                                        } else if (sound->envelopes != NULL) {
-                                               assert(sound->raw_data_size >= 
sound->raw_position);
+                                               assert(sound->raw_data_size > 
sound->raw_position);
                                                use_envelopes(sound, 
sound->raw_data_size - sound->raw_position);
                                        }
+
+                                       // Test if we will get problems... 
Should not happen...
+                                       assert(sound->raw_position + 
sound->raw_data_size-1 - sound->raw_position < sound->raw_data_size);
+
                                        SDL_MixAudio(stream, (const 
Uint8*)(sound->raw_data + sound->raw_position), 
-                                               sound->raw_data_size - 
sound->raw_position,
+                                               sound->raw_data_size-1 - 
sound->raw_position,
                                                SDL_MIX_MAXVOLUME);
                                        index = sound->raw_data_size - 
sound->raw_position;
                                }
@@ -695,13 +699,14 @@
 
                                // Then we decode some data
                                int outsize = 0;        
-#ifdef USE_FFMPEG
+
                                // If we need to loop, we reset the data pointer
-                               if (sound->data_size == sound->position && 
sound->loop_count != 0) {
+                               if (sound->data_size == sound->position+1 && 
sound->loop_count != 0) {
                                        sound->loop_count--;
                                        sound->position = 0;
                                }
                                
+#ifdef USE_FFMPEG
                                if (sound->raw_data_size > 0) 
memset(sound->raw_data, 0, sound->raw_data_size);
 
                                long bytes_decoded = 0;
@@ -729,12 +734,7 @@
 
 #elif defined(USE_MAD)
 
-                               // If we need to loop, we reset the data 
pointer, and tell mad about it
-                               if (sound->data_size == sound->position && 
sound->loop_count != 0) {
-                                       sound->position = 0;
-                                       sound->loop_count--;
-                               }
-
+                               // Setup the mad decoder
                                mad_stream_buffer(&sound->stream, 
sound->data+sound->position, sound->data_size-sound->position);
 
                                int ret;
@@ -836,48 +836,52 @@
                                // If the volume needs adjustments we call a 
function to do that
                                if (handler->m_sound_data[i]->volume != 100) {
                                        
adjust_volume((int16_t*)(sound->raw_data + sound->raw_position), 
-                                               sound->raw_data_size - 
sound->raw_position,
+                                               sound->raw_data_size-1 - 
sound->raw_position,
                                                
handler->m_sound_data[i]->volume);
                                } else if (sound->envelopes != NULL) {
                                        assert(buffer_length >= index);
                                        use_envelopes(sound, buffer_length - 
index);
                                }
 
+                               // Test if we will get problems... Should not 
happen...
+                               assert(sound->raw_position + buffer_length - 
index < sound->raw_data_size);
+
                                // Then we mix the newly decoded data
                                SDL_MixAudio((Uint8*)(stream+index),(const 
Uint8*) sound->raw_data, 
                                                buffer_length - index,
                                                SDL_MIX_MAXVOLUME);
 
                                sound->raw_position = buffer_length - index;
-
                                sound->samples_played += buffer_length - index;
                                
                        // When the current sound has enough decoded data to 
fill 
                        // the buffer, we do just that.
-                       } else if (sound->raw_data_size - sound->raw_position 
>= buffer_length ) {
+                       } else if (sound->raw_data_size - sound->raw_position > 
buffer_length ) {
                        
                                // If the volume needs adjustments we call a 
function to do that
                                if (handler->m_sound_data[i]->volume != 100) {
                                        
adjust_volume((int16_t*)(sound->raw_data + sound->raw_position), 
-                                               sound->raw_data_size - 
sound->raw_position,
+                                               sound->raw_data_size-1 - 
sound->raw_position,
                                                
handler->m_sound_data[i]->volume);
                                } else if (sound->envelopes != NULL) {
                                        use_envelopes(sound, buffer_length);
                                }
 
+                               // Test if we will get problems... Should not 
happen...
+                               assert(sound->raw_position + buffer_length < 
sound->raw_data_size);
+
                                // Mix the raw data
                                SDL_MixAudio((Uint8*)(stream),(const Uint8*) 
(sound->raw_data + sound->raw_position), 
                                                buffer_length,
                                                SDL_MIX_MAXVOLUME);
 
                                sound->raw_position += buffer_length;
-
                                sound->samples_played += buffer_length;
 
                        // When the current sound doesn't have anymore data to 
decode,
                        // and doesn't loop (anymore), but still got unplayed 
data,
                        // we put the last data on the stream
-                       } else if (sound->raw_data_size - sound->raw_position < 
buffer_length && sound->raw_data_size > sound->raw_position) {
+                       } else if (sound->raw_data_size - sound->raw_position 
<= buffer_length && sound->raw_data_size > sound->raw_position+1) {
                        
                                // If the volume needs adjustments we call a 
function to do that
                                if (handler->m_sound_data[i]->volume != 100) {
@@ -888,13 +892,14 @@
                                        use_envelopes(sound, 
sound->raw_data_size - sound->raw_position);
                                }
 
+                               // Test if we will get problems... Should not 
happen...
+                               assert(sound->raw_position + 
sound->raw_data_size-1 - sound->raw_position < sound->raw_data_size);
+
                                // Mix the remaining data
                                SDL_MixAudio((Uint8*)(stream),(const Uint8*) 
(sound->raw_data + sound->raw_position), 
-                                               sound->raw_data_size - 
sound->raw_position,
+                                               sound->raw_data_size-1 - 
sound->raw_position,
                                                SDL_MIX_MAXVOLUME);
-                               sound->raw_position = sound->raw_data_size;
-
-                       } else {
+                               sound->raw_position = sound->raw_data_size-1;
                        }
                        
                        // Sound is done, remove it from the active list (mp3)




reply via email to

[Prev in Thread] Current Thread [Next in Thread]