<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name" translatable="no">AppRTC</string>
    <string name="settings_name" translatable="no">AppRTC Settings</string>
    <string name="disconnect_call">Disconnect Call</string>
    <string name="room_names">Room names:</string>
    <string name="room_description">
        Please enter a room name. Room names are shared with everyone, so think
        of something unique and send it to a friend.
    </string>
    <string name="connect_text">Connect</string>
    <string name="invalid_url_title">Invalid URL</string>
    <string name="invalid_url_text">The URL or room name you entered resulted in an invalid URL: %1$s
    </string>
    <string name="channel_error_title">Connection error</string>
    <string name="connecting_to">Connecting to: %1$s</string>
    <string name="missing_url">FATAL ERROR: Missing URL to connect to.</string>
    <string name="ok">OK</string>
    <string name="switch_camera">Switch front/back camera</string>
    <string name="toggle_debug">Toggle debug view</string>
    <string name="action_settings">Settings</string>
    <string name="add_room_description">Add new room to the list</string>
    <string name="remove_room_description">Remove room from the list</string>
    <string name="connect_description">Connect to the room</string>
    <string name="connect_loopback_description">Loopback connection</string>

    <!-- Settings strings. -->
    <string name="pref_room_key">room_preference</string>
    <string name="pref_room_list_key">room_list_preference</string>

    <string name="pref_videosettings_key">video_settings_key</string>
    <string name="pref_videosettings_title">WebRTC video settings.</string>

    <string name="pref_videocall_key">videocall_preference</string>
    <string name="pref_videocall_title">Video call.</string>
    <string name="pref_videocall_dlg">Enable video in a call.</string>
    <string name="pref_videocall_default">true</string>

    <string name="pref_resolution_key">resolution_preference</string>
    <string name="pref_resolution_title">Video resolution.</string>
    <string name="pref_resolution_dlg">Enter AppRTC local video resolution.</string>
    <string name="pref_resolution_default">Default</string>

    <string name="pref_fps_key">fps_preference</string>
    <string name="pref_fps_title">Camera fps.</string>
    <string name="pref_fps_dlg">Enter local camera fps.</string>
    <string name="pref_fps_default">Default</string>

    <string name="pref_startvideobitrate_key">startvideobitrate_preference</string>
    <string name="pref_startvideobitrate_title">Start video bitrate setting.</string>
    <string name="pref_startvideobitrate_dlg">Start video bitrate setting.</string>
    <string name="pref_startvideobitrate_default">Default</string>

    <string name="pref_startvideobitratevalue_key">startvideobitratevalue_preference</string>
    <string name="pref_startvideobitratevalue_title">Video encoder start bitrate.</string>
    <string name="pref_startvideobitratevalue_dlg">Enter video encoder start bitrate in kbps.</string>
    <string name="pref_startvideobitratevalue_default">1000</string>

    <string name="pref_videocodec_key">videocodec_preference</string>
    <string name="pref_videocodec_title">Default video codec.</string>
    <string name="pref_videocodec_dlg">Select default video codec.</string>
    <string name="pref_videocodec_default">VP8</string>

    <string name="pref_hwcodec_key">hwcodec_preference</string>
    <string name="pref_hwcodec_title">Video codec hardware acceleration.</string>
    <string name="pref_hwcodec_dlg">Use hardware accelerated video codec (if available).</string>
    <string name="pref_hwcodec_default">true</string>

    <string name="pref_value_enabled">Enabled</string>
    <string name="pref_value_disabled">Disabled</string>

    <string name="pref_audiosettings_key">audio_settings_key</string>
    <string name="pref_audiosettings_title">WebRTC audio settings.</string>

    <string name="pref_startaudiobitrate_key">startaudiobitrate_preference</string>
    <string name="pref_startaudiobitrate_title">Audio bitrate setting.</string>
    <string name="pref_startaudiobitrate_dlg">Audio bitrate setting.</string>
    <string name="pref_startaudiobitrate_default">Default</string>

    <string name="pref_startaudiobitratevalue_key">startaudiobitratevalue_preference</string>
    <string name="pref_startaudiobitratevalue_title">Audio codec bitrate.</string>
    <string name="pref_startaudiobitratevalue_dlg">Enter audio codec bitrate in kbps.</string>
    <string name="pref_startaudiobitratevalue_default">32</string>

    <string name="pref_audiocodec_key">audiocodec_preference</string>
    <string name="pref_audiocodec_title">Default audio codec.</string>
    <string name="pref_audiocodec_dlg">Select default audio codec.</string>
    <string name="pref_audiocodec_default">OPUS</string>

    <string name="pref_miscsettings_key">misc_settings_key</string>
    <string name="pref_miscsettings_title">Miscellaneous settings.</string>

    <string name="pref_cpu_usage_detection_key">cpu_usage_detection</string>
    <string name="pref_cpu_usage_detection_title">CPU overuse detection.</string>
    <string name="pref_cpu_usage_detection_dlg">Adapt transmission to CPU status.</string>
    <string name="pref_cpu_usage_detection_default" translatable="false">true</string>

    <string name="pref_room_server_url_key">room_server_url_preference</string>
    <string name="pref_room_server_url_title">Room server URL.</string>
    <string name="pref_room_server_url_dlg">Enter a room server URL.</string>
    <string name="pref_room_server_url_default" translatable="false">https://apprtc.appspot.com</string>

    <string name="pref_displayhud_key">displayhud_preference</string>
    <string name="pref_displayhud_title">Display call statistics.</string>
    <string name="pref_displayhud_dlg">Display call statistics.</string>
    <string name="pref_displayhud_default" translatable="false">false</string>

</resources>
