C/C++

#include "typecast.h"
#include <stdio.h>

int main() {
    // 클라이언트 초기화
    TypecastClient* client = typecast_client_create("YOUR_API_KEY");
    if (!client) return 1;

    // 텍스트를 음성으로 변환
    TypecastTTSRequest request = {0};
    request.text = "안녕하세요! 저는 친절한 텍스트-투-스피치 에이전트입니다.";
    request.voice_id = "tc_672c5f5ce59fac2a48faeaee";
    request.model = TYPECAST_MODEL_SSFM_V30;
    request.language = "kor";

    TypecastTTSResponse* response = typecast_text_to_speech(client, &request);
    if (response) {
        // 오디오 파일 저장
        FILE* fp = fopen("output.wav", "wb");
        fwrite(response->audio_data, 1, response->audio_size, fp);
        fclose(fp);

        printf("Audio saved! Duration: %.2fs, Size: %zu bytes\n",
               response->duration, response->audio_size);

        typecast_tts_response_free(response);
    }

    // 정리
    typecast_client_destroy(client);
    return 0;
}

TypecastRecommendedVoicesResponse* voices = typecast_recommend_voices(
    client,
    "warm female voice for a product tutorial",
    3
);

if (voices) {
    for (int i = 0; i < voices->count; i++) {
        printf("%s %s %.3f\n",
            voices->voices[i].voice_id,
            voices->voices[i].voice_name,
            voices->voices[i].score);
    }
    typecast_recommended_voices_response_free(voices);
}

#include <stdlib.h>

// 환경 변수 사용
// export TYPECAST_API_KEY="your-api-key-here"
const char* api_key = getenv("TYPECAST_API_KEY");
TypecastClient* client = typecast_client_create(api_key);

// 또는 직접 전달
TypecastClient* client = typecast_client_create("your-api-key-here");

// 또는 커스텀 베이스 URL과 함께
TypecastClient* client = typecast_client_create_with_host(
    "your-api-key-here", 
    "https://custom-api.example.com"
);

TypecastClient* client = typecast_client_create_with_host(
    NULL,
    "https://your-proxy.example.com"
);

TypecastTTSRequest request = {0};
request.text = "커스터마이징된 오디오 출력입니다!";
request.voice_id = "tc_672c5f5ce59fac2a48faeaee";
request.model = TYPECAST_MODEL_SSFM_V30;
request.language = "kor";

// 출력 설정 구성
TypecastOutput output = TYPECAST_OUTPUT_DEFAULT();
output.use_target_lufs = 1;
output.target_lufs = -14.0f;                    // 범위: -70 ~ 0 (LUFS)
output.audio_pitch = 2;                        // 범위: -12 to +12 반음
output.audio_tempo = 1.2f;                     // 범위: 0.5x to 2.0x
output.audio_format = TYPECAST_AUDIO_FORMAT_MP3;  // 옵션: WAV, MP3
request.output = &output;

request.seed = 42;  // 부호 없는 정수 시드 (재현 가능한 결과)

TypecastTTSResponse* response = typecast_text_to_speech(client, &request);
if (response) {
    const char* ext = (response->format == TYPECAST_AUDIO_FORMAT_MP3) ? "mp3" : "wav";
    char filename[64];
    snprintf(filename, sizeof(filename), "output.%s", ext);
    
    FILE* fp = fopen(filename, "wb");
    fwrite(response->audio_data, 1, response->audio_size, fp);
    fclose(fp);
    
    printf("Duration: %.2fs, Format: %s\n", response->duration, ext);
    typecast_tts_response_free(response);
}

int result = typecast_generate_to_file(
    client,
    "hello.mp3",
    "안녕하세요, 타입캐스트입니다.",
    "tc_672c5f5ce59fac2a48faeaee", /* voice_id는 https://studio.typecast.ai/developers/api/voices 에서 확인하세요. */
    NULL
);

TypecastSpeechComposer* composer = typecast_speech_composer_create(client);
TypecastComposerSettings defaults = {0};
defaults.voice_id = "tc_672c5f5ce59fac2a48faeaee";
defaults.model = TYPECAST_MODEL_SSFM_V30;
typecast_speech_composer_defaults(composer, &defaults);

typecast_speech_composer_say(
    composer,
    "안녕하세요<|5s|>반갑습니다<|1s|>오늘<|2s|>날씨는 어떤 것 같으세요?",
    NULL
);

TypecastTTSResponse* audio = typecast_speech_composer_generate(composer, TYPECAST_AUDIO_FORMAT_WAV);
typecast_tts_response_free(audio);
typecast_speech_composer_destroy(composer);

TypecastSpeechComposer* composer = typecast_speech_composer_create(client);
TypecastComposerSettings defaults = {0};
defaults.voice_id = "tc_672c5f5ce59fac2a48faeaee";
defaults.model = TYPECAST_MODEL_SSFM_V30;
typecast_speech_composer_defaults(composer, &defaults);

typecast_speech_composer_say(composer, "Hello there", NULL);
typecast_speech_composer_pause(composer, 5.0f);

TypecastComposerSettings second = {0};
second.voice_id = "tc_60e5426de8b95f1d3000d7b5";
second.output.audio_pitch = 2;
typecast_speech_composer_say(composer, "Nice to meet you", &second);
typecast_speech_composer_pause(composer, 2.0f);
typecast_speech_composer_say(composer, "How does the weather feel?", NULL);

TypecastTTSResponse* audio = typecast_speech_composer_generate(composer, TYPECAST_AUDIO_FORMAT_WAV);
/* write audio->audio_data / audio->audio_len to conversation.wav */
typecast_tts_response_free(audio);
typecast_speech_composer_destroy(composer);

// 모든 음성 가져오기
TypecastVoicesResponse* voices = typecast_get_voices(client, NULL);

// 또는 조건으로 필터링
TypecastModel model = TYPECAST_MODEL_SSFM_V30;
TypecastGender gender = TYPECAST_GENDER_FEMALE;
TypecastAge age = TYPECAST_AGE_YOUNG_ADULT;

TypecastVoicesFilter filter = {0};
filter.model = &model;
filter.gender = &gender;
filter.age = &age;

TypecastVoicesResponse* filtered = typecast_get_voices(client, &filter);

// 음성 정보 표시
if (voices) {
    for (size_t i = 0; i < voices->count; i++) {
        TypecastVoice* v = &voices->voices[i];
        printf("ID: %s, Name: %s\n", v->voice_id, v->voice_name);
        printf("Gender: %d, Age: %d\n", v->gender, v->age);

        for (size_t j = 0; j < v->models_count; j++) {
            printf("Model: %s, Emotions: ",
                   typecast_model_to_string(v->models[j].version));
            for (size_t k = 0; k < v->models[j].emotions_count; k++) {
                printf("%s ", v->models[j].emotions[k]);
            }
            printf("\n");
        }
    }
    typecast_voices_response_free(voices);
}

// 자동 언어 감지 (권장 - language 필드 생략)
TypecastTTSRequest request = {0};
request.text = "こんにちは。お元気ですか。";
request.voice_id = "tc_672c5f5ce59fac2a48faeaee";
request.model = TYPECAST_MODEL_SSFM_V30;
// language가 NULL이면 자동으로 감지됩니다

TypecastTTSResponse* response = typecast_text_to_speech(client, &request);

// 또는 ISO 639-3 코드로 언어를 명시적으로 지정
TypecastTTSRequest korean_request = {0};
korean_request.text = "안녕하세요. 반갑습니다.";
korean_request.voice_id = "tc_672c5f5ce59fac2a48faeaee";
korean_request.model = TYPECAST_MODEL_SSFM_V30;
korean_request.language = "kor";  // ISO 639-3 언어 코드

TypecastTTSResponse* korean_response = typecast_text_to_speech(client, &korean_request);

// 실시간 재생을 위한 원시 PCM 추출 (44바이트 WAV 헤더 건너뛰기)
static int g_first = 1;

static int on_chunk(const uint8_t *data, size_t len, void *user_data) {
    const uint8_t *pcm = data;
    size_t pcm_len = len;

    if (g_first) {
        pcm += 44;       // WAV 헤더 건너뛰기
        pcm_len -= 44;
        g_first = 0;
    }
    // pcm은 32000 Hz 16비트 모노 원시 PCM
    // 오디오 출력으로 전달 (예: PortAudio, ALSA)
    play_audio(pcm, pcm_len);  // 재생 함수
    return 0;
}

#include "typecast.h"
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    TypecastClient *client = typecast_client_new("YOUR_API_KEY");

    TypecastTTSRequestWithTimestamps req = {
        .voice_id    = "tc_60e5426de8b95f1d3000d7b5",
        .text        = "Hello. How are you?",
        .model       = "ssfm-v30",
        .granularity = TYPECAST_GRANULARITY_WORD,
    };

    TypecastTTSWithTimestampsResponse *result =
        typecast_text_to_speech_with_timestamps(client, &req);

    FILE *f = fopen("output.wav", "wb");
    fwrite(result->audio_data, 1, result->audio_size, f);
    fclose(f);

    printf("재생 시간: %.3f초\n", result->audio_duration);
    for (size_t i = 0; i < result->words_count; i++) {
        printf("  [%.3fs – %.3fs] %s\n",
               result->words[i].start_time,
               result->words[i].end_time,
               result->words[i].text);
    }

    typecast_tts_with_timestamps_response_free(result);
    typecast_client_free(client);
    return 0;
}

// 문자 단위 정렬 - 일본어·중국어에 필수
TypecastTTSRequestWithTimestamps req = {
    .voice_id    = "tc_60e5426de8b95f1d3000d7b5",
    .text        = "Hello. How are you?",
    .model       = "ssfm-v30",
    .granularity = TYPECAST_GRANULARITY_CHAR,
};

char *srt = typecast_tts_with_timestamps_to_srt(result);
FILE *fs = fopen("output.srt", "w");
fputs(srt, fs);
fclose(fs);
free(srt);

char *vtt = typecast_tts_with_timestamps_to_vtt(result);
FILE *fv = fopen("output.vtt", "w");
fputs(vtt, fv);
fclose(fv);
free(vtt);

#include "typecast.h"

TypecastTTSResponse* response = typecast_text_to_speech(client, &request);

if (!response) {
    const TypecastError* err = typecast_client_get_error(client);
    
    switch (err->code) {
        case TYPECAST_ERROR_UNAUTHORIZED:
            // 401: 유효하지 않은 API 키
            fprintf(stderr, "Invalid API key: %s\n", err->message);
            break;
        case TYPECAST_ERROR_PAYMENT_REQUIRED:
            // 402: 크레딧 부족
            fprintf(stderr, "Insufficient credits: %s\n", err->message);
            break;
        case TYPECAST_ERROR_NOT_FOUND:
            // 404: 리소스를 찾을 수 없음
            fprintf(stderr, "Voice not found: %s\n", err->message);
            break;
        case TYPECAST_ERROR_UNPROCESSABLE_ENTITY:
            // 422: 유효성 검사 오류
            fprintf(stderr, "Validation error: %s\n", err->message);
            break;
        case TYPECAST_ERROR_RATE_LIMIT:
            // 429: 요청 제한 초과
            fprintf(stderr, "Rate limit exceeded - please try again later\n");
            break;
        case TYPECAST_ERROR_INTERNAL_SERVER:
            // 500: 서버 오류
            fprintf(stderr, "Server error: %s\n", err->message);
            break;
        default:
            fprintf(stderr, "API error (%d): %s\n", err->code, err->message);
            break;
    }
}

#define TYPECAST_CPP_WRAPPER
#include "typecast.h"

#include <fstream>
#include <iostream>

int main() {
    try {
        // 클라이언트 초기화
        typecast::Client client("YOUR_API_KEY");

        // 텍스트를 음성으로 변환
        typecast::TTSRequest request;
        request.text = "안녕하세요! 저는 친절한 텍스트-투-스피치 에이전트입니다.";
        request.voiceId = "tc_672c5f5ce59fac2a48faeaee";
        request.model = typecast::Model::SSFM_V30;
        request.language = "kor";

        auto response = client.textToSpeech(request);

        // 오디오 파일 저장
        std::ofstream file("output.wav", std::ios::binary);
        file.write(reinterpret_cast<const char*>(response.audioData.data()), 
                   response.audioData.size());

        std::cout << "Audio saved! Duration: " << response.duration << "s\n";

    } catch (const typecast::TypecastException& e) {
        std::cerr << "Error (" << e.code << "): " << e.what() << "\n";
        return 1;
    }

    return 0;
}