Update stt/stt_google.py

stt/stt_google.py

@@ -76,124 +76,84 @@ class GoogleSTT(STTInterface):
             
             log_info(f"📊 Transcribing {len(audio_data)} bytes of audio")
             
-            # ✅ Detaylı audio analizi - logda
-            import struct
-            samples = struct.unpack(f'{len(audio_data)//2}h', audio_data)
-            total_samples = len(samples)
-            
-            # 1. Genel istatistikler
-            non_zero_samples = [s for s in samples if s != 0]
-            zero_count = total_samples - len(non_zero_samples)
-            
-            if non_zero_samples:
-                avg_amplitude = sum(abs(s) for s in non_zero_samples) / len(non_zero_samples)
-                max_amplitude = max(abs(s) for s in non_zero_samples)
-            else:
-                avg_amplitude = 0
-                max_amplitude = 0
-            
-            log_info(f"🔍 Audio stats: {total_samples} total samples, {zero_count} zeros ({zero_count/total_samples:.1%})")
-            log_info(f"🔍 Non-zero stats: avg={avg_amplitude:.1f}, max={max_amplitude}")
-            
-            # 2. Bölüm bazlı analiz (10 bölüme ayır)
-            section_size = total_samples // 10
-            log_info(f"🔍 Section analysis (each {section_size} samples):")
-            
-            for i in range(10):
-                start_idx = i * section_size
-                end_idx = (i + 1) * section_size if i < 9 else total_samples
-                section = samples[start_idx:end_idx]
+            # ✅ Debug - audio verisi analizi
+            if len(audio_data) > 100:
+                # İlk ve son 50 byte'ı kontrol et
+                first_50 = audio_data[:50]
+                last_50 = audio_data[-50:]
+                log_debug(f"Audio first 50 bytes: {first_50.hex()}")
+                log_debug(f"Audio last 50 bytes: {last_50.hex()}")
                 
-                section_non_zero = [s for s in section if s != 0]
-                section_max = max(abs(s) for s in section_non_zero) if section_non_zero else 0
-                section_avg = sum(abs(s) for s in section_non_zero) / len(section_non_zero) if section_non_zero else 0
-                zero_ratio = (len(section) - len(section_non_zero)) / len(section)
-                
-                log_info(f"  Section {i+1}: max={section_max}, avg={section_avg:.1f}, zeros={zero_ratio:.1%}")
-            
-            # 3. İlk konuşma başlangıcını bul
-            speech_threshold = 500  # RMS eşiği
-            speech_start_idx = -1
-            
-            # 100 sample'lık pencerelerle RMS hesapla
-            window_size = 100
-            for i in range(0, total_samples - window_size, window_size):
-                window = samples[i:i + window_size]
-                rms = (sum(s * s for s in window) / window_size) ** 0.5
-                
-                if rms > speech_threshold:
-                    speech_start_idx = i
-                    break
+                # Ortalama amplitude kontrolü
+                import struct
+                samples = struct.unpack(f'{len(audio_data)//2}h', audio_data)
+                avg_amplitude = sum(abs(s) for s in samples) / len(samples)
+                max_amplitude = max(abs(s) for s in samples)
+                log_debug(f"Audio stats: avg_amplitude={avg_amplitude:.1f}, max_amplitude={max_amplitude}")
             
-            if speech_start_idx >= 0:
-                speech_start_time = speech_start_idx / config.sample_rate
-                log_info(f"🎤 Speech detected starting at sample {speech_start_idx} ({speech_start_time:.2f}s)")
-            else:
-                log_warning("⚠️ No speech detected above threshold in entire audio")
+            # ✅ Convert to WAV format for better compatibility
+            wav_audio = self._convert_to_wav(audio_data, config.sample_rate)
+            log_info(f"🔧 WAV conversion: {len(audio_data)} PCM → {len(wav_audio)} WAV")
             
-            # 4. Audio'nun gerçekten boş olup olmadığını kontrol et
-            if max_amplitude < 100:
-                log_warning(f"⚠️ Audio appears silent: max_amplitude={max_amplitude}")
-                return None
-            
-            if zero_count / total_samples > 0.95:  # %95'den fazla sıfır
-                log_warning(f"⚠️ Audio is mostly zeros: {zero_count/total_samples:.1%}")
-                return None
-            
-            wav_audio = self._convert_to_wav(audio_data, 16000)
-                    
             # Configure recognition
+            language_code = self._map_language_code(config.language)
+    
+            # ✅ WAV audio kullanıyoruz artık
             recognition_config = RecognitionConfig(
                 encoding=RecognitionConfig.AudioEncoding.LINEAR16,
                 sample_rate_hertz=16000,
                 language_code="tr-TR",
-                audio_channel_count=1,
+                audio_channel_count=1,  # Frontend mono audio gönderiyor
                 enable_separate_recognition_per_channel=False,
-                enable_automatic_punctuation=True,
             )
-            
-            # ✅ WAV audio gönder
-            audio = RecognitionAudio(content=wav_audio)
+                
+            log_debug(f"Recognition config: language={language_code}, sample_rate={config.sample_rate}, model={config.model}")
     
-            # ✅ RAW audio gönder, WAV conversion yapmadan
-            audio = RecognitionAudio(content=audio_data)  # Direkt raw PCM
+            # ✅ Create audio object with WAV data (not raw PCM)
+            audio = RecognitionAudio(content=wav_audio)  # wav_audio kullan, audio_data değil
             
             # Perform synchronous recognition
-            log_info(f"🔄 Sending {len(audio_data)} bytes RAW PCM to Google Cloud Speech API...")
+            log_info(f"🔄 Sending {len(wav_audio)} bytes WAV to Google Cloud Speech API...")
             response = self.client.recognize(config=recognition_config, audio=audio)
     
-            # ✅ Detaylı response analizi
+            # ✅ Debug response
+            log_debug(f"API Response: {response}")
             log_info(f"🔍 Google response details:")
-            log_info(f"  - Has results: {bool(response.results)}")
-            log_info(f"  - Results count: {len(response.results) if response.results else 0}")
+            log_info(f"- Has results: {bool(response.results)}")
+            log_info(f"- Results count: {len(response.results)}")
             
             if hasattr(response, 'total_billed_time'):
-                if response.total_billed_time and response.total_billed_time.total_seconds() > 0:
-                    log_info(f"  - Billed time: {response.total_billed_time.total_seconds()}s")
-                else:
-                    log_info(f"  - Billed time: 0s (no audio processed)")
-            
+                log_info(f"- Billed time: {response.total_billed_time.total_seconds()}s")
+            else:
+                log_info(f"- Billed time: 0s (no audio processed)")
+    
             # Process results
-            if response.results and len(response.results) > 0:
-                for i, result in enumerate(response.results):
-                    log_info(f"  - Result {i}: {len(result.alternatives)} alternatives")
-                    if result.alternatives:
-                        for j, alt in enumerate(result.alternatives):
-                            log_info(f"    - Alt {j}: '{alt.transcript}' (conf: {alt.confidence:.3f})")
-                
+            if response.results:
                 result = response.results[0]
-                if result.alternatives and len(result.alternatives) > 0:
+                if result.alternatives:
                     alternative = result.alternatives[0]
                     
+                    # Extract word timestamps if available
+                    word_timestamps = None
+                    if config.enable_word_timestamps and hasattr(alternative, 'words'):
+                        word_timestamps = [
+                            {
+                                "word": word_info.word,
+                                "start_time": word_info.start_time.total_seconds(),
+                                "end_time": word_info.end_time.total_seconds()
+                            }
+                            for word_info in alternative.words
+                        ]
+                    
                     transcription = TranscriptionResult(
                         text=alternative.transcript,
                         confidence=alternative.confidence,
                         timestamp=datetime.now().timestamp(),
-                        language="tr-TR",
-                        word_timestamps=None
+                        language=language_code,
+                        word_timestamps=word_timestamps
                     )
                     
-                    log_info(f"✅ Transcription SUCCESS: '{alternative.transcript}' (confidence: {alternative.confidence:.2f})")
+                    log_info(f"✅ Transcription: '{alternative.transcript}' (confidence: {alternative.confidence:.2f})")
                     return transcription
             
             log_warning("⚠️ No transcription results - Google couldn't recognize speech")