public void stopCallback(ErrorCode ret) {
if (ErrorCode.succeeded(ret)) {
m_VideoParams = null;
m_AudioParams = null;
cleanupBuffers();
try {
if (m_Listener != null) {
m_Listener.onBroadcastStopped();
}
} catch (Exception x) {
reportError(x.toString());
}
if (m_LoggedIn) {
setBroadcastState(BroadcastState.ReadyToBroadcast);
} else {
setBroadcastState(BroadcastState.Initialized);
}
} else {
// there's not really a good state to go into here
setBroadcastState(BroadcastState.ReadyToBroadcast);
String err = ErrorCode.getString(ret);
reportError(String.format("stopCallback got failure: %s", err));
}
}
public ErrorCode submitFrame(FrameBuffer bgraFrame) {
if (this.getIsPaused()) {
resumeBroadcasting();
} else if (!this.getIsBroadcasting()) {
return ErrorCode.TTV_EC_STREAM_NOT_STARTED;
}
ErrorCode ret = m_Stream.submitVideoFrame(bgraFrame);
// if there is a problem when submitting a frame let the client know
if (ret != ErrorCode.TTV_EC_SUCCESS) {
String err = ErrorCode.getString(ret);
if (ErrorCode.succeeded(ret)) {
reportWarning(String.format("Warning in SubmitTexturePointer: %s\n", err));
} else {
reportError(String.format("Error in SubmitTexturePointer: %s\n", err));
// errors are not recoverable
stopBroadcasting();
}
if (m_Listener != null) {
m_Listener.onframeSubmissionIssue(ret);
}
}
return ret;
}
/**
* Requests a list of all games matching the given search string. The result will be returned
* asynchronously via OnGameNameListReceived.
*
* @param str Whether or not the request was made
*/
public void requestGameNameList(String str) {
ErrorCode ret = m_Stream.getGameNameList(str);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in GetGameNameList: %s\n", err));
}
}
public void getUserInfoCallback(ErrorCode result, UserInfo userInfo) {
m_UserInfo = userInfo;
if (ErrorCode.failed(result)) {
String err = ErrorCode.getString(result);
reportError(String.format("UserInfoDoneCallback got failure: %s", err));
}
}
protected boolean checkError(ErrorCode err) {
if (ErrorCode.failed(err)) {
reportError(ErrorCode.getString(err));
return false;
}
return true;
}
public String getJson() {
JsonObject jsobj = new JsonObject();
if (errorMsg == null) {
jsobj.add("errorCode", new JsonPrimitive(errorCode.name()));
jsobj.add("errorMsg", new JsonPrimitive("null"));
} else {
jsobj.add("errorCode", new JsonPrimitive(errorCode.name()));
jsobj.add("errorMsg", new JsonPrimitive(errorMsg));
}
return jsobj.toString();
}
/**
* Use this in place of valueOf.
*
* @param value real value
* @return ErrorCode corresponding to the value
*/
public static ErrorCode fromValue(String value) {
if (value == null || "".equals(value)) {
throw new IllegalArgumentException("Value cannot be null or empty!");
}
for (ErrorCode enumEntry : ErrorCode.values()) {
if (enumEntry.toString().equals(value)) {
return enumEntry;
}
}
throw new IllegalArgumentException("Cannot create enum from " + value + " value!");
}
/**
* Send a singular action metadata point to Twitch's metadata service.
*
* @param name A specific name for an event meant to be queryable
* @param streamTime Number of milliseconds into the broadcast for when event occurs
* @param humanDescription Long form string to describe the meaning of an event. Maximum length is
* 1000 characters
* @param data A valid JSON object that is the payload of an event. Values in this JSON object
* have to be strings. Maximum of 50 keys are allowed. Maximum length for values are 255
* characters.
* @return True if submitted and no error, false otherwise.
*/
public boolean sendActionMetaData(
String name, long streamTime, String humanDescription, String data) {
ErrorCode ret =
m_Stream.sendActionMetaData(m_AuthToken, name, streamTime, humanDescription, data);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error while sending meta data: %s\n", err));
return false;
}
return true;
}
public void getGameNameListCallback(ErrorCode result, GameInfoList list) {
if (ErrorCode.failed(result)) {
String err = ErrorCode.getString(result);
reportError(String.format("GameNameListCallback got failure: %s", err));
}
try {
if (m_Listener != null) {
m_Listener.onGameNameListReceived(result, list == null ? new GameInfo[0] : list.list);
}
} catch (Exception x) {
reportError(x.toString());
}
}
/**
* Sets the visible data about the channel of the currently logged in user.
*
* @param channel The name of the channel.
* @param game The name of the game. If the empty string or null then this parameter is ignored.
* @param title The title of the channel. If the empty string or null then this parameter is
* ignored.
* @return Whether or not the request was made
*/
public boolean setStreamInfo(String channel, String game, String title) {
if (!m_LoggedIn) {
return false;
}
if (channel == null || channel == "") {
channel = m_UserName;
}
if (game == null) {
game = "";
}
if (title == null) {
title = "";
}
StreamInfoForSetting info = new StreamInfoForSetting();
info.streamTitle = title;
info.gameName = game;
ErrorCode err = m_Stream.setStreamInfo(m_AuthToken, channel, info);
checkError(err);
return ErrorCode.succeeded(err);
}
/** Initializes the SDK and the controller. */
public boolean initializeTwitch() {
if (m_SdkInitialized) {
return false;
}
String dllPath = m_DllPath;
if (dllPath == "") {
dllPath = "./";
}
m_Stream.setStreamCallbacks(this);
ErrorCode err = m_Stream.initialize(m_ClientId, VideoEncoder.TTV_VID_ENC_DEFAULT, dllPath);
if (!checkError(err)) {
m_Stream.setStreamCallbacks(null);
return false;
}
err = m_Stream.setTraceLevel(MessageLevel.TTV_ML_ERROR);
if (!checkError(err)) {
m_Stream.setStreamCallbacks(null);
return false;
}
if (ErrorCode.succeeded(err)) {
m_SdkInitialized = true;
setBroadcastState(BroadcastState.Initialized);
return true;
}
return false;
}
/**
* Terminates the broadcast.
*
* @return Whether or not successfully stopped
*/
public boolean stopBroadcasting() {
if (!this.getIsBroadcasting()) {
return false;
}
ErrorCode ret = m_Stream.stop(true);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error while stopping the broadcast: %s", err));
return false;
}
setBroadcastState(BroadcastState.Stopping);
return ErrorCode.succeeded(ret);
}
public void onLoginAttemptComplete(ErrorCode result) {
if (ErrorCode.succeeded(result)) {
if (enableChat) {
initChat();
}
}
}
public void getArchivingStateCallback(ErrorCode result, ArchivingState state) {
m_ArchivingState = state;
if (ErrorCode.failed(result)) {
// String err = ErrorCode.getString(result);
// reportWarning(String.Format("ArchivingStateDoneCallback got failure: {0}", err));
}
}
/** 初始化 string2ErrorCodeMap，errorMap */
static {
for (ErrorCode errorCode : ErrorCode.values()) {
string2ErrorCodeMap.put(errorCode.name(), errorCode);
}
for (String errorFile : errorFiles) {
InputStream in = null;
try {
in = ErrorUtils.class.getClassLoader().getResourceAsStream(errorFile);
errorMap.putAll(ErrorDOLoader.loadXml(in));
} finally {
if (in != null) {
IOUtils.closeQuietly(in);
}
}
}
}
protected void updateStreamInfo() {
long now = System.nanoTime();
long delta = (now - m_LastStreamInfoUpdateTime) / 1000000000;
// only check every so often
if (delta < s_StreamInfoUpdateInterval) {
return;
}
m_LastStreamInfoUpdateTime = now;
ErrorCode ret = m_Stream.getStreamInfo(m_AuthToken, m_UserName);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in TTV_GetStreamInfo: %s", err));
}
}
public void onGameNameListReceived(ErrorCode result, GameInfo[] list) {
if (ErrorCode.succeeded(result)) {
System.out.println("Game names:");
for (int i = 0; i < list.length; ++i) {
System.out.println(" " + list[i].name);
}
}
}
/**
* Pauses the current broadcast and displays the default pause screen.
*
* @return Whether or not successfully paused
*/
public boolean pauseBroadcasting() {
if (!this.getIsBroadcasting()) {
return false;
}
ErrorCode ret = m_Stream.pauseVideo();
if (ErrorCode.failed(ret)) {
// not streaming anymore
stopBroadcasting();
String err = ErrorCode.getString(ret);
reportError(String.format("Error pausing stream: %s\n", err));
} else {
setBroadcastState(BroadcastState.Paused);
}
return ErrorCode.succeeded(ret);
}
/**
* Runs a commercial on the channel. Must be broadcasting.
*
* @return Whether or not successful
*/
public boolean runCommercial() {
if (!this.getIsBroadcasting()) {
return false;
}
ErrorCode err = m_Stream.runCommercial(m_AuthToken);
checkError(err);
return ErrorCode.succeeded(err);
}
/**
* Send the ending datapoint of an event that has a beginning and end.
*
* @param name A specific name for an event meant to be queryable
* @param streamTime Number of milliseconds into the broadcast for when event occurs
* @param sequenceId Associates a start and end event together. Use the corresponding sequenceId
* returned in TTV_SendStartSpanMetaData
* @param humanDescription Long form string to describe the meaning of an event. Maximum length is
* 1000 characters
* @param data A valid JSON object that is the payload of an event. Values in this JSON object
* have to be strings. Maximum of 50 keys are allowed. Maximum length for values are 255
* characters.
* @return True if submitted and no error, false otherwise.
*/
public boolean endSpanMetaData(
String name, long streamTime, long sequenceId, String humanDescription, String data) {
if (sequenceId == -1) {
reportError(String.format("Invalid sequence id: %d\n", sequenceId));
return false;
}
ErrorCode ret =
m_Stream.sendEndSpanMetaData(
m_AuthToken, name, streamTime, sequenceId, humanDescription, data);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in SendStopSpanMetaData: %s\n", err));
return false;
}
return true;
}
private void readRstStream(Handler handler, int length, byte flags, int streamId)
throws IOException {
if (length != 4) throw ioException("TYPE_RST_STREAM length: %d != 4", length);
if (streamId == 0) throw ioException("TYPE_RST_STREAM streamId == 0");
int errorCodeInt = source.readInt();
ErrorCode errorCode = ErrorCode.fromHttp2(errorCodeInt);
if (errorCode == null) {
throw ioException("TYPE_RST_STREAM unexpected error code: %d", errorCodeInt);
}
handler.rstStream(streamId, errorCode);
}
/**
* Returns a fully populated VideoParams struct based on the given width, height and frame rate.
* This function is not the advised way to setup VideoParams because it has no information about
* the user's maximum bitrate. Use the other version of GetRecommendedVideoParams instead if
* possible.
*
* @param width The broadcast width
* @param height The broadcast height
* @param frameRate The broadcast frames per second
* @return The VideoParams
*/
public VideoParams getRecommendedVideoParams(int width, int height, int frameRate) {
VideoParams videoParams = new VideoParams();
videoParams.outputWidth = width;
videoParams.outputHeight = height;
videoParams.targetFps = frameRate;
videoParams.pixelFormat = determinePixelFormat();
videoParams.encodingCpuUsage = EncodingCpuUsage.TTV_ECU_HIGH;
videoParams.disableAdaptiveBitrate = false;
videoParams.verticalFlip = false;
// Compute the rest of the fields based on the given parameters
ErrorCode ret = m_Stream.getDefaultParams(videoParams);
if (ErrorCode.failed(ret)) {
String err = ErrorCode.getString(ret);
reportError(String.format("Error in GetDefaultParams: %s", err));
return null;
}
return videoParams;
}
public void startCallback(ErrorCode ret) {
if (ErrorCode.succeeded(ret)) {
try {
if (m_Listener != null) {
m_Listener.onBroadcastStarted();
}
} catch (Exception x) {
reportError(x.toString());
}
setBroadcastState(BroadcastState.Broadcasting);
} else {
m_VideoParams = null;
m_AudioParams = null;
setBroadcastState(BroadcastState.ReadyToBroadcast);
String err = ErrorCode.getString(ret);
reportError(String.format("startCallback got failure: %s", err));
}
}
public void loginCallback(ErrorCode result, ChannelInfo channelInfo) {
if (ErrorCode.succeeded(result)) {
m_ChannelInfo = channelInfo;
setBroadcastState(BroadcastState.LoggedIn);
m_LoggedIn = true;
} else {
setBroadcastState(BroadcastState.Initialized);
m_LoggedIn = false;
String err = ErrorCode.getString(result);
reportError(String.format("LoginCallback got failure: %s", err));
}
try {
if (m_Listener != null) {
m_Listener.onLoginAttemptComplete(result);
}
} catch (Exception x) {
reportError(x.toString());
}
}
public void requestAuthTokenCallback(ErrorCode result, AuthToken authToken) {
if (ErrorCode.succeeded(result)) {
// Now that the user is authorized the information can be requested about which server to
// stream to
m_AuthToken = authToken;
setBroadcastState(BroadcastState.Authenticated);
} else {
m_AuthToken.data = "";
setBroadcastState(BroadcastState.Initialized);
String err = ErrorCode.getString(result);
reportError(String.format("RequestAuthTokenDoneCallback got failure: %s", err));
}
try {
if (m_Listener != null) {
m_Listener.onAuthTokenRequestComplete(result, authToken);
}
} catch (Exception x) {
reportError(x.toString());
}
}
/**
* Begins broadcast using the given VideoParams.
*
* @param videoParams The video params
* @return Whether or not successfully broadcasting
*/
public boolean startBroadcasting(VideoParams videoParams) {
if (videoParams == null || !this.getIsReadyToBroadcast()) {
return false;
}
m_VideoParams = videoParams.clone();
// Setup the audio parameters
m_AudioParams = new AudioParams();
m_AudioParams.audioEnabled =
m_EnableAudio && getIsAudioSupported(); // // only enable audio if possible
if (!allocateBuffers()) {
m_VideoParams = null;
m_AudioParams = null;
return false;
}
ErrorCode ret =
m_Stream.start(videoParams, m_AudioParams, m_IngestServer, StartFlags.None, true);
if (ErrorCode.failed(ret)) {
cleanupBuffers();
String err = ErrorCode.getString(ret);
reportError(String.format("Error while starting to broadcast: %s", err));
m_VideoParams = null;
m_AudioParams = null;
return false;
}
setBroadcastState(BroadcastState.Starting);
return true;
}
private void readGoAway(Handler handler, int flags, int length, int streamId)
throws IOException {
if (length < 8) throw ioException("TYPE_GOAWAY length < 8: %s", length);
int lastStreamId = in.readInt();
int errorCodeInt = in.readInt();
int opaqueDataLength = length - 8;
ErrorCode errorCode = ErrorCode.fromHttp2(errorCodeInt);
if (errorCode == null) {
throw ioException("TYPE_RST_STREAM unexpected error code: %d", errorCodeInt);
}
if (Util.skipByReading(in, opaqueDataLength) != opaqueDataLength) {
throw new IOException("TYPE_GOAWAY opaque data was truncated");
}
handler.goAway(lastStreamId, errorCode);
}
public void getIngestServersCallback(ErrorCode result, IngestList ingestList) {
if (ErrorCode.succeeded(result)) {
m_IngestList = ingestList;
// assume we're going to use the default ingest server unless overridden by the client
m_IngestServer = m_IngestList.getDefaultServer();
setBroadcastState(BroadcastState.ReceivedIngestServers);
try {
if (m_Listener != null) {
m_Listener.onIngestListReceived(ingestList);
}
} catch (Exception x) {
reportError(x.toString());
}
} else {
String err = ErrorCode.getString(result);
reportError(String.format("IngestListCallback got failure: %s", err));
// try again
setBroadcastState(BroadcastState.LoggingIn);
}
}
private void readRstStream(FrameReader.Handler paramHandler, int paramInt1, byte paramByte, int paramInt2)
{
if (paramInt1 != 4) {
throw Http2.ioException("TYPE_RST_STREAM length: %d != 4", new Object[] { Integer.valueOf(paramInt1) });
}
if (paramInt2 == 0) {
throw Http2.ioException("TYPE_RST_STREAM streamId == 0", new Object[0]);
}
paramInt1 = this.source.readInt();
ErrorCode localErrorCode = ErrorCode.fromHttp2(paramInt1);
if (localErrorCode == null) {
throw Http2.ioException("TYPE_RST_STREAM unexpected error code: %d", new Object[] { Integer.valueOf(paramInt1) });
}
paramHandler.rstStream(paramInt2, localErrorCode);
}
public void getStreamInfoCallback(ErrorCode result, StreamInfo streamInfo) {
if (ErrorCode.succeeded(result)) {
m_StreamInfo = streamInfo;
try {
if (m_Listener != null) {
m_Listener.onStreamInfoUpdated(streamInfo);
}
} catch (Exception x) {
reportError(x.toString());
}
} else {
// String err = ErrorCode.getString(result);
// reportWarning(String.Format("StreamInfoDoneCallback got failure: {0}", err));
}
}
