TFTYPE
serverThread(void *arg)
{
  STREAMING_SERVER *server = arg;
  server->state = STREAMING_ACCEPTING;

  while (server->state == STREAMING_ACCEPTING)
    {
      struct sockaddr_in addr;
      socklen_t addrlen = sizeof(struct sockaddr_in);
      int sockfd =
	accept(server->socket, (struct sockaddr *) &addr, &addrlen);

      if (sockfd > 0)
	{
	  // Create a new process and transfer the control to that
	  RTMP_Log(RTMP_LOGDEBUG, "%s: accepted connection from %s\n", __FUNCTION__,
	      inet_ntoa(addr.sin_addr));
	  processTCPrequest(server, sockfd);
	  RTMP_Log(RTMP_LOGDEBUG, "%s: processed request\n", __FUNCTION__);
	}
      else
	{
	  RTMP_Log(RTMP_LOGERROR, "%s: accept failed", __FUNCTION__);
	}
    }
  server->state = STREAMING_STOPPED;
  TFRET();
}

void RTMP_LogHex(int level, const uint8_t *data, unsigned long len)
{
	unsigned long i;
	char line[50], *ptr;

	if ( level > RTMP_debuglevel )
		return;

	ptr = line;

	for(i=0; i<len; i++) {
		*ptr++ = hexdig[0x0f & (data[i] >> 4)];
		*ptr++ = hexdig[0x0f & data[i]];
		if ((i & 0x0f) == 0x0f) {
			*ptr = '\0';
			ptr = line;
			RTMP_Log(level, "%s", line);
		} else {
			*ptr++ = ' ';
		}
	}
	if (i & 0x0f) {
		*ptr = '\0';
		RTMP_Log(level, "%s", line);
	}
}

int ExecuteRPCResult(RTMP *r, AMFObject *obj, YLENGStream *yle, int *redirected) {
  AVal rpcKind;
  AVal mediaxml;
  char *playurl, *tvpayOnly;
  AVal parsedHost = {NULL, 0};
  AVal parsedPlaypath = {NULL, 0};
  AVal parsedApp = {NULL, 0};

  *redirected = FALSE;

  AMFProp_GetString(AMF_GetProp(obj, NULL, 3), &rpcKind);
  
  if (!AVMATCH(&rpcKind, &av_e0))
    return TRUE;

  AMFProp_GetString(AMF_GetProp(obj, NULL, 4), &mediaxml);
  RTMP_Log(RTMP_LOGDEBUG, "clip data:\n%.*s", mediaxml.av_len, mediaxml.av_val);

  playurl = GetXMLNodeContent(mediaxml.av_val, "url");
  if (!playurl)
    return FALSE;

  if (!ParseYLEPlaypath(playurl, &parsedHost, &parsedApp, &parsedPlaypath)) {
    RTMP_Log(RTMP_LOGERROR, "Couldn't parse stream url %s!", playurl);
    free(playurl);
    return FALSE;
  }

  // FIXME: old r->Link.playpath may be leaked
  r->Link.playpath.av_len = parsedPlaypath.av_len;
  r->Link.playpath.av_val = malloc(parsedPlaypath.av_len*sizeof(char));
  strncpy(r->Link.playpath.av_val, parsedPlaypath.av_val, r->Link.playpath.av_len);

  RTMP_Log(RTMP_LOGDEBUG, "New playpath   : %.*s",
           r->Link.playpath.av_len, r->Link.playpath.av_val);

  if (!AVMATCH(&parsedHost, &r->Link.hostname)) {
    RTMP_Log(RTMP_LOGDEBUG, "Redirected to another server: %.*s",
             parsedHost.av_len, parsedHost.av_val);

    // FIXME: old value may be leaked
    r->Link.hostname.av_val = malloc(parsedHost.av_len*sizeof(char));
    r->Link.hostname.av_len = parsedHost.av_len;
    memcpy(r->Link.hostname.av_val, parsedHost.av_val, parsedHost.av_len);

    *redirected = TRUE;
  }

  tvpayOnly = GetXMLNodeContent(mediaxml.av_val, "tvpayOnly");
  if (tvpayOnly) {
    yle->tvFeeRequired = (strcmp(tvpayOnly, "false")!=0);
    free(tvpayOnly);
  }

  free(playurl);

  return RTMP_SendCreateStream(r);
}

void RTMP_LogHexString ( int level, const uint8_t *data, unsigned long len )
{
#define BP_OFFSET 9
#define BP_GRAPH 60
#define BP_LEN	80
	char	line[BP_LEN];
	unsigned long i;

	if ( !data || level > RTMP_debuglevel )
	{
		return;
	}

	/* in case len is zero */
	line[0] = '\0';

	for ( i = 0 ; i < len ; i++ )
	{
		int n = i % 16;
		unsigned off;

		if ( !n )
		{
			if ( i )
			{
				RTMP_Log ( level, "%s", line );
			}

			memset ( line, ' ', sizeof ( line ) - 2 );
			line[sizeof ( line ) - 2] = '\0';

			off = i % 0x0ffffU;

			line[2] = hexdig[0x0f & ( off >> 12 )];
			line[3] = hexdig[0x0f & ( off >> 8 )];
			line[4] = hexdig[0x0f & ( off >> 4 )];
			line[5] = hexdig[0x0f & off];
			line[6] = ':';
		}

		off = BP_OFFSET + n * 3 + ( ( n >= 8 ) ? 1 : 0 );
		line[off] = hexdig[0x0f & ( data[i] >> 4 )];
		line[off + 1] = hexdig[0x0f & data[i]];

		off = BP_GRAPH + n + ( ( n >= 8 ) ? 1 : 0 );

		if ( isprint ( data[i] ) )
		{
			line[BP_GRAPH + n] = data[i];
		}
		else
		{
			line[BP_GRAPH + n] = '.';
		}
	}

	RTMP_Log ( level, "%s", line );
}

void QRtmp::setSwfAge(int age)
{
    if(age < 0)
        RTMP_Log(RTMP_LOGERROR, "SWF Age must be non-negative, ignoring\n");
    else
        m_swfAge = age;
}

void QRtmp::setConnData(const QByteArray &data)
{
    m_connData = data;
    AVal connData = aval(m_connData);
    if(!RTMP_SetOpt(m_rtmp, &av_conn, &connData))
        RTMP_Log(RTMP_LOGERROR, "Invalid AMF parameter");
}

STREAMING_SERVER *
startStreaming(const char *address, int port)
{
	struct sockaddr_in addr;
	int sockfd, tmp;
	STREAMING_SERVER *server;

	sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sockfd == -1)
	{
		RTMP_Log(RTMP_LOGERROR, "%s, couldn't create socket", __FUNCTION__);
		return 0;
	}

	tmp = 1;
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
		(char *)&tmp, sizeof(tmp));

	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = inet_addr(address);	//htonl(INADDR_ANY);
	addr.sin_port = htons(port);

	if (bind(sockfd, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) ==
		-1)
	{
		RTMP_Log(RTMP_LOGERROR, "%s, TCP bind failed for port number: %d", __FUNCTION__,
			port);
		return 0;
	}

	if (listen(sockfd, 10) == -1)
	{
		RTMP_Log(RTMP_LOGERROR, "%s, listen failed", __FUNCTION__);
		closesocket(sockfd);
		return 0;
	}

	server = (STREAMING_SERVER *)calloc(1, sizeof(STREAMING_SERVER));
	server->socket = sockfd;

	//ThreadCreate(serverThread, server);
	std::thread theThread(serverThread, server);
	theThread.join();

	return server;
}

TFTYPE
serverThread(void *arg)
{
  STREAMING_SERVER *server = arg;
  server->state = STREAMING_ACCEPTING;

  while (server->state == STREAMING_ACCEPTING)
    {
      struct sockaddr_in addr;
      socklen_t addrlen = sizeof(struct sockaddr_in);
      int sockfd =
	accept(server->socket, (struct sockaddr *) &addr, &addrlen);

      if (sockfd > 0)
	{
#ifdef linux
	  struct sockaddr_in dest;
	  char destch[16];
	  socklen_t destlen = sizeof(struct sockaddr_in);
	  getsockopt(sockfd, SOL_IP, SO_ORIGINAL_DST, &dest, &destlen);
	  strcpy(destch, inet_ntoa(dest.sin_addr));
	  RTMP_Log(RTMP_LOGDEBUG, "%s: accepted connection from %s to %s\n", __FUNCTION__,
	      inet_ntoa(addr.sin_addr), destch);
#else
	  RTMP_Log(RTMP_LOGDEBUG, "%s: accepted connection from %s\n", __FUNCTION__,
	      inet_ntoa(addr.sin_addr));
#endif
	  /* Create a new thread and transfer the control to that */
	  doServe(server, sockfd);
	  RTMP_Log(RTMP_LOGDEBUG, "%s: processed request\n", __FUNCTION__);
	}
      else
	{
	  RTMP_Log(RTMP_LOGERROR, "%s: accept failed", __FUNCTION__);
	}
    }
  server->state = STREAMING_STOPPED;
  TFRET();
}

void QRtmp::stopBlocking(int timeoutSec)
{
    if(isRunning())
    {
        QEventLoop waiter;
        connect(this, SIGNAL(finished()), &waiter, SLOT(quit()));
        QTimer::singleShot(timeoutSec * 1000, &waiter, SLOT(quit()));
        m_stop = true;
        waiter.exec();

        if(isRunning()) // timeout exceeded
            RTMP_Log(RTMP_LOGWARNING, "Thread has not finished while timeout has exceeded");
    }
}

int ExecuteAuthenticationDetails(RTMP *r, AMFObject *proplist, YLENGStream *yle) {
  long authResult = -1;
  int i;
  
  for (i=0; i<AMF_CountProp(proplist); i++) {
    AVal name;
    AMFObjectProperty *prop = AMF_GetProp(proplist, NULL, i);
    AMFProp_GetName(prop, &name);

    if (AVMATCH(&name, &av_locatedInBroadcastTerritory)) {
      yle->locatedInBroadcastTerritory = AMFProp_GetBoolean(prop);
    } else if (AVMATCH(&name, &av_randomAuth)) {
      authResult = ((long)AMFProp_GetNumber(prop) + 447537687) % 6834253;
    } else if (AVMATCH(&name, &av_tvFeeActivated)) {
      yle->tvFeeActivated = AMFProp_GetBoolean(prop);
    }
  }

  if (authResult != -1) {
    RTMPPacket packet;
    char pbuf[128], *pend = pbuf+sizeof(pbuf);

    packet.m_nChannel = 0x03;   // control channel
    packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
    packet.m_packetType = 0x11; // FLEX MESSAGE
    packet.m_nTimeStamp = RTMP_GetTime();
    packet.m_nInfoField2 = 0;
    packet.m_hasAbsTimestamp = 0;

    packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
    char *enc = packet.m_body;
    *enc++ = 0x00;   // Unknown
    enc = AMF_EncodeString(enc, pend, &av_authenticateRandomNumber);
    enc = AMF_EncodeNumber(enc, pend, 0);
    *enc++ = AMF_NULL;
    enc = AMF_EncodeNumber(enc, pend, (double)authResult);

    packet.m_nBodySize = enc-packet.m_body;

    RTMP_Log(RTMP_LOGDEBUG, "sending authenticateRandomNumber");

    return RTMP_SendPacket(r, &packet, FALSE);
  }

  return FALSE;
}

int RequestData(RTMP *r, YLENGStream *yle) {
  RTMPPacket packet;
  char pbuf[128], *pend = pbuf+sizeof(pbuf);
  AVal clipID;

  packet.m_nChannel = 0x03;   // control channel
  packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
  packet.m_packetType = 0x11; // FLEX MESSAGE
  packet.m_nTimeStamp = RTMP_GetTime();
  packet.m_nInfoField2 = 0;
  packet.m_hasAbsTimestamp = 0;

  packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
  char *enc = packet.m_body;
  *enc++ = 0x00;   // Unknown
  enc = AMF_EncodeString(enc, pend, &av_requestData);
  enc = AMF_EncodeNumber(enc, pend, 0);
  *enc++ = AMF_NULL;
  enc = AMF_EncodeString(enc, pend, &av_e0);

  if ((r->Link.lFlags & RTMP_LF_LIVE) != 0) {
    char *tmp = malloc(yle->clipID.av_len+12);
    strcpy(tmp, "streams/fi/");
    strncat(tmp, yle->clipID.av_val, yle->clipID.av_len);
    STR2AVAL(clipID, tmp);
    enc = AMF_EncodeString(enc, pend, &clipID);
    free(tmp);
  } else {
    char *tmp = malloc(yle->clipID.av_len+2);
    strcpy(tmp, "/");
    strncat(tmp, yle->clipID.av_val, yle->clipID.av_len);
    STR2AVAL(clipID, tmp);
    enc = AMF_EncodeString(enc, pend, &clipID);
    free(tmp);
  }

  if (!enc) {
    RTMP_Log(RTMP_LOGERROR, "Buffer too short in RequestData");
    return FALSE;
  }

  packet.m_nBodySize = enc-packet.m_body;

  return RTMP_SendPacket(r, &packet, FALSE);
}

int ExecuteInvokedMethod(RTMP *r, const AVal *method, AMFObject *obj, void *ctx) {
  struct YLENGStream *yle = (struct YLENGStream *)ctx;
  int redirected = FALSE;

  if (!yle || yle->yleAuth == 0)
    return RTMP_CB_NOT_HANDLED;

  if (AVMATCH(method, &av_authenticationDetails)) {
    AMFObject list;
    AMFProp_GetObject(AMF_GetProp(obj, NULL, 3), &list);
    if (!ExecuteAuthenticationDetails(r, &list, yle))
      return RTMP_CB_ERROR_STOP;
    
    if (yle->clipID.av_len) {
      if (!RequestData(r, yle))
        return RTMP_CB_ERROR_STOP;
    } else if (!RTMP_SendCreateStream(r)) {
      return RTMP_CB_ERROR_STOP;
    }
        
    return RTMP_CB_SUCCESS;

  } else if (AVMATCH(method, &av_randomNumberAuthenticated)) {
    ExecuteRandomNumberAuthenticated(r);
    return RTMP_CB_SUCCESS;

  } else if (AVMATCH(method, &av_rpcResult)) {
    if (!ExecuteRPCResult(r, obj, yle, &redirected))
      return RTMP_CB_ERROR_STOP;

    //if (redirected && !ConnectRedirected(r, r->Link.seekTime, yle))
    //  return RTMP_CB_ERROR_STOP;

    return RTMP_CB_SUCCESS;

  } else if (AVMATCH(method, &av_rpcError)) {
    RTMP_Log(RTMP_LOGERROR, "RTMP server returned RPC error");
    return RTMP_CB_ERROR_STOP;
  }

  return RTMP_CB_NOT_HANDLED;
}

void
stopStreaming(STREAMING_SERVER * server)
{
  assert(server);

  if (server->state != STREAMING_STOPPED)
    {
      if (server->state == STREAMING_IN_PROGRESS)
	{
	  server->state = STREAMING_STOPPING;

	  // wait for streaming threads to exit
	  while (server->state != STREAMING_STOPPED)
	    msleep(1);
	}

      if (closesocket(server->socket))
	RTMP_Log(RTMP_LOGERROR, "%s: Failed to close listening socket, error %d",
	    GetSockError());

      server->state = STREAMING_STOPPED;
    }
}

HTTPResult
HTTP_get(struct HTTP_ctx *http, const char *url, HTTP_read_callback *cb) {
    char *host, *path;
    char *p1, *p2;
    char hbuf[256];
    int port = 80;
#ifdef CRYPTO
    int ssl = 0;
#endif
    int hlen, flen = 0;
    int rc, i;
    int len_known;
    HTTPResult ret = HTTPRES_OK;
    struct sockaddr_in sa;
    RTMPSockBuf sb = {0};

    http->status = -1;

    memset(&sa, 0, sizeof(struct sockaddr_in));
    sa.sin_family = AF_INET;

    /* we only handle http here */
    if (strncasecmp(url, "http", 4))
        return HTTPRES_BAD_REQUEST;

    if (url[4] == 's') {
#ifdef CRYPTO
        ssl = 1;
        port = 443;
        if (!RTMP_TLS_ctx)
            RTMP_TLS_Init();
#else
        return HTTPRES_BAD_REQUEST;
#endif
    }

    p1 = strchr(url + 4, ':');
    if (!p1 || strncmp(p1, "://", 3))
        return HTTPRES_BAD_REQUEST;

    host = p1 + 3;
    path = strchr(host, '/');
    hlen = path - host;
    strncpy(hbuf, host, hlen);
    hbuf[hlen] = '\0';
    host = hbuf;
    p1 = strrchr(host, ':');
    if (p1) {
        *p1++ = '\0';
        port = atoi(p1);
    }

    sa.sin_addr.s_addr = inet_addr(host);
    if (sa.sin_addr.s_addr == INADDR_NONE) {
        struct hostent *hp = gethostbyname(host);
        if (!hp || !hp->h_addr)
            return HTTPRES_LOST_CONNECTION;
        sa.sin_addr = *(struct in_addr *) hp->h_addr;
    }
    sa.sin_port = htons(port);
    sb.sb_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sb.sb_socket == -1)
        return HTTPRES_LOST_CONNECTION;
    i =
        sprintf(sb.sb_buf,
                "GET %s HTTP/1.0\r\nUser-Agent: %s\r\nHost: %s\r\nReferer: %.*s\r\n",
                path, AGENT, host, (int) (path - url + 1), url);
    if (http->date[0])
        i += sprintf(sb.sb_buf + i, "If-Modified-Since: %s\r\n", http->date);
    i += sprintf(sb.sb_buf + i, "\r\n");

    if (connect
            (sb.sb_socket, (struct sockaddr *) &sa, sizeof(struct sockaddr)) < 0) {
        ret = HTTPRES_LOST_CONNECTION;
        goto leave;
    }
#ifdef CRYPTO
    if (ssl) {
#ifdef NO_SSL
        RTMP_Log(RTMP_LOGERROR, "%s, No SSL/TLS support", __FUNCTION__);
        ret = HTTPRES_BAD_REQUEST;
        goto leave;
#else
        TLS_client(RTMP_TLS_ctx, sb.sb_ssl);
        TLS_setfd(sb.sb_ssl, sb.sb_socket);
        if (TLS_connect(sb.sb_ssl) < 0) {
            RTMP_Log(RTMP_LOGERROR, "%s, TLS_Connect failed", __FUNCTION__);
            ret = HTTPRES_LOST_CONNECTION;
            goto leave;
        }
#endif
    }
#endif
    RTMPSockBuf_Send(&sb, sb.sb_buf, i);

    /* set timeout */
#define HTTP_TIMEOUT    5
    {
        SET_RCVTIMEO(tv, HTTP_TIMEOUT);
        if (setsockopt
//.........这里部分代码省略.........

//.........这里部分代码省略.........
                    for (i = 0; i < l; i += 2)
                        *ptr++ = (HEX2BIN(in[i]) << 4) | HEX2BIN(in[i + 1]);
                    got++;
                }
                else if (!strncmp(buf, "date: ", 6)) {
                    buf[strlen(buf) - 1] = '\0';
                    strncpy(date, buf + 6, sizeof(date));
                    got++;
                }
                else if (!strncmp(buf, "ctim: ", 6)) {
                    buf[strlen(buf) - 1] = '\0';
                    ctim = make_unix_time(buf + 6);
                    got++;
                }
                else if (!strncmp(buf, "url: ", 5))
                    break;
            }
            break;
        }
        break;
    }

    cnow = time(NULL);
    /* If we got a cache time, see if it's young enough to use directly */
    if (age && ctim > 0) {
        ctim = cnow - ctim;
        ctim /= 3600 * 24;    /* seconds to days */
        if (ctim < age)        /* ok, it's new enough */
            goto out;
    }

    in.first = 1;
    HMAC_setup(in.ctx, "Genuine Adobe Flash Player 001", 30);
    inflateInit(&zs);
    in.zs = &zs;

    http.date = date;
    http.data = &in;

    httpres = HTTP_get(&http, url, swfcrunch);

    inflateEnd(&zs);

    if (httpres != HTTPRES_OK && httpres != HTTPRES_OK_NOT_MODIFIED) {
        ret = -1;
        if (httpres == HTTPRES_LOST_CONNECTION)
            RTMP_Log(RTMP_LOGERROR, "%s: connection lost while downloading swfurl %s",
                     __FUNCTION__, url);
        else if (httpres == HTTPRES_NOT_FOUND)
            RTMP_Log(RTMP_LOGERROR, "%s: swfurl %s not found", __FUNCTION__, url);
        else
            RTMP_Log(RTMP_LOGERROR, "%s: couldn't contact swfurl %s (HTTP error %d)",
                     __FUNCTION__, url, http.status);
    }
    else {
        if (got && pos)
            fseek(f, pos, SEEK_SET);
        else {
            char *q;
            if (!f)
                f = fopen(path, "w");
            if (!f) {
                int err = errno;
                RTMP_Log(RTMP_LOGERROR,
                         "%s: couldn't open %s for writing, errno %d (%s)",
                         __FUNCTION__, path, err, strerror(err));
                ret = -1;
                goto out;
            }
            fseek(f, 0, SEEK_END);
            q = strchr(url, '?');
            if (q)
                i = q - url;
            else
                i = strlen(url);

            fprintf(f, "url: %.*s\n", i, url);
        }
        strtime(&cnow, cctim);
        fprintf(f, "ctim: %s\n", cctim);

        if (!in.first) {
            HMAC_finish(in.ctx, hash, hlen);
            *size = in.size;

            fprintf(f, "date: %s\n", date);
            fprintf(f, "size: %08x\n", in.size);
            fprintf(f, "hash: ");
            for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
                fprintf(f, "%02x", hash[i]);
            fprintf(f, "\n");
        }
    }
    HMAC_close(in.ctx);
out:
    free(path);
    if (f)
        fclose(f);
    return ret;
}

int
ServePacket(STREAMING_SERVER *server, RTMP *r, RTMPPacket *packet)
{
  int ret = 0;

  RTMP_Log(RTMP_LOGDEBUG, "%s, received packet type %02X, size %lu bytes", __FUNCTION__,
    packet->m_packetType, packet->m_nBodySize);

  switch (packet->m_packetType)
    {
    case 0x01:
      // chunk size
//      HandleChangeChunkSize(r, packet);
      break;

    case 0x03:
      // bytes read report
      break;

    case 0x04:
      // ctrl
//      HandleCtrl(r, packet);
      break;

    case 0x05:
      // server bw
//      HandleServerBW(r, packet);
      break;

    case 0x06:
      // client bw
 //     HandleClientBW(r, packet);
      break;

    case 0x08:
      // audio data
      //RTMP_Log(RTMP_LOGDEBUG, "%s, received: audio %lu bytes", __FUNCTION__, packet.m_nBodySize);
      break;

    case 0x09:
      // video data
      //RTMP_Log(RTMP_LOGDEBUG, "%s, received: video %lu bytes", __FUNCTION__, packet.m_nBodySize);
      break;

    case 0x0F:			// flex stream send
      break;

    case 0x10:			// flex shared object
      break;

    case 0x11:			// flex message
      {
	RTMP_Log(RTMP_LOGDEBUG, "%s, flex message, size %lu bytes, not fully supported",
	    __FUNCTION__, packet->m_nBodySize);
	//RTMP_LogHex(packet.m_body, packet.m_nBodySize);

	// some DEBUG code
	/*RTMP_LIB_AMFObject obj;
	   int nRes = obj.Decode(packet.m_body+1, packet.m_nBodySize-1);
	   if(nRes < 0) {
	   RTMP_Log(RTMP_LOGERROR, "%s, error decoding AMF3 packet", __FUNCTION__);
	   //return;
	   }

	   obj.Dump(); */

	if (ServeInvoke(server, r, packet, 1))
	  RTMP_Close(r);
	break;
      }
    case 0x12:
      // metadata (notify)
      break;

    case 0x13:
      /* shared object */
      break;

    case 0x14:
      // invoke
      RTMP_Log(RTMP_LOGDEBUG, "%s, received: invoke %lu bytes", __FUNCTION__,
	  packet->m_nBodySize);
      //RTMP_LogHex(packet.m_body, packet.m_nBodySize);

      if (ServeInvoke(server, r, packet, 0))
	RTMP_Close(r);
      break;

    case 0x16:
      /* flv */
	break;
    default:
      RTMP_Log(RTMP_LOGDEBUG, "%s, unknown packet type received: 0x%02x", __FUNCTION__,
	  packet->m_packetType);
#ifdef _DEBUG
      RTMP_LogHex(RTMP_LOGDEBUG, packet->m_body, packet->m_nBodySize);
#endif
    }
  return ret;
}

void doServe(STREAMING_SERVER * server,	// server socket and state (our listening socket)
  int sockfd	// client connection socket
  )
{
  server->state = STREAMING_IN_PROGRESS;

  RTMP rtmp = { 0 };		/* our session with the real client */
  RTMPPacket packet = { 0 };

  // timeout for http requests
  fd_set fds;
  struct timeval tv;

  memset(&tv, 0, sizeof(struct timeval));
  tv.tv_sec = 5;

  FD_ZERO(&fds);
  FD_SET(sockfd, &fds);

  if (select(sockfd + 1, &fds, NULL, NULL, &tv) <= 0)
    {
      RTMP_Log(RTMP_LOGERROR, "Request timeout/select failed, ignoring request");
      goto quit;
    }
  else
    {
      RTMP_Init(&rtmp);
      rtmp.m_sb.sb_socket = sockfd;
      if (!RTMP_Serve(&rtmp))
	{
	  RTMP_Log(RTMP_LOGERROR, "Handshake failed");
	  goto cleanup;
	}
    }
  server->arglen = 0;
  while (RTMP_IsConnected(&rtmp) && RTMP_ReadPacket(&rtmp, &packet))
    {
      if (!RTMPPacket_IsReady(&packet))
	continue;
      ServePacket(server, &rtmp, &packet);
      RTMPPacket_Free(&packet);
    }

cleanup:
  RTMP_LogPrintf("Closing connection... ");
  RTMP_Close(&rtmp);
  /* Should probably be done by RTMP_Close() ... */
  rtmp.Link.playpath.av_val = NULL;
  rtmp.Link.tcUrl.av_val = NULL;
  rtmp.Link.swfUrl.av_val = NULL;
  rtmp.Link.pageUrl.av_val = NULL;
  rtmp.Link.app.av_val = NULL;
  rtmp.Link.flashVer.av_val = NULL;
  RTMP_LogPrintf("done!\n\n");

quit:
  if (server->state == STREAMING_IN_PROGRESS)
    server->state = STREAMING_ACCEPTING;

  return;
}

int
OpenResumeFile(const char *flvFile,	// file name [in]
			   FILE ** file,	// opened file [out]
			   off_t * size,	// size of the file [out]
			   char **metaHeader,	// meta data read from the file [out]
			   uint32_t * nMetaHeaderSize,	// length of metaHeader [out]
			   double *duration)	// duration of the stream in ms [out]
{
	size_t bufferSize = 0;
	char hbuf[16], *buffer = NULL;

	*nMetaHeaderSize = 0;
	*size = 0;

	*file = fopen(flvFile, "r+b");
	if (!*file)
		return RD_SUCCESS;		// RD_SUCCESS, because we go to fresh file mode instead of quiting

	fseek(*file, 0, SEEK_END);
	*size = ftello(*file);
	fseek(*file, 0, SEEK_SET);

	if (*size > 0)
	{
		// verify FLV format and read header
		uint32_t prevTagSize = 0;

		// check we've got a valid FLV file to continue!
		if (fread(hbuf, 1, 13, *file) != 13)
		{
			RTMP_Log(RTMP_LOGERROR, "Couldn't read FLV file header!");
			return RD_FAILED;
		}
		if (hbuf[0] != 'F' || hbuf[1] != 'L' || hbuf[2] != 'V'
			|| hbuf[3] != 0x01)
		{
			RTMP_Log(RTMP_LOGERROR, "Invalid FLV file!");
			return RD_FAILED;
		}

		if ((hbuf[4] & 0x05) == 0)
		{
			RTMP_Log(RTMP_LOGERROR,
					 "FLV file contains neither video nor audio, aborting!");
			return RD_FAILED;
		}

		uint32_t dataOffset = AMF_DecodeInt32(hbuf + 5);
		fseek(*file, dataOffset, SEEK_SET);

		if (fread(hbuf, 1, 4, *file) != 4)
		{
			RTMP_Log(RTMP_LOGERROR, "Invalid FLV file: missing first prevTagSize!");
			return RD_FAILED;
		}
		prevTagSize = AMF_DecodeInt32(hbuf);
		if (prevTagSize != 0)
		{
			RTMP_Log(RTMP_LOGWARNING,
					 "First prevTagSize is not zero: prevTagSize = 0x%08X",
					 prevTagSize);
		}

		// go through the file to find the meta data!
		off_t pos = dataOffset + 4;
		int bFoundMetaHeader = FALSE;

		while (pos < *size - 4 && !bFoundMetaHeader)
		{
			fseeko(*file, pos, SEEK_SET);
			if (fread(hbuf, 1, 4, *file) != 4)
				break;

			uint32_t dataSize = AMF_DecodeInt24(hbuf + 1);

			if (hbuf[0] == 0x12)
			{
				if (dataSize > bufferSize)
				{
					/* round up to next page boundary */
					bufferSize = dataSize + 4095;
					bufferSize ^= (bufferSize & 4095);
					free(buffer);
					buffer = (char *)malloc(bufferSize);
					if (!buffer)
						return RD_FAILED;
				}

				fseeko(*file, pos + 11, SEEK_SET);
				if (fread(buffer, 1, dataSize, *file) != dataSize)
					break;

				AMFObject metaObj;
				int nRes = AMF_Decode(&metaObj, buffer, dataSize, FALSE);
				if (nRes < 0)
				{
					RTMP_Log(RTMP_LOGERROR, "%s, error decoding meta data packet",
							 __FUNCTION__);
					break;
				}
//.........这里部分代码省略.........

int QRtmp::download()
{
    qint32 now, lastUpdate;
    int bufferSize = 64 * 1024;
    char *buffer = (char *) malloc(bufferSize);
    int nRead = 0;
    off_t size = 0;

    m_rtmp->m_read.timestamp = dSeek;
    m_percent = 0.0;

    if(m_rtmp->m_read.timestamp)
        RTMP_Log(RTMP_LOGDEBUG, "Continuing at TS: %d ms\n", m_rtmp->m_read.timestamp);

    if(m_bLiveStream)
        RTMP_LogPrintf("Starting Live Stream\n");
    else
    {
        // print initial status
        // Workaround to exit with 0 if the file is fully (> 99.9%) downloaded
        if(m_duration > 0)
        {
            if((double) m_rtmp->m_read.timestamp >= (double) m_duration * 999.0)
            {
                RTMP_LogPrintf("Already Completed at: %.3f sec Duration=%.3f sec\n",
                               (double) m_rtmp->m_read.timestamp / 1000.0,
                               (double) m_duration / 1000.0);
                return RD_SUCCESS;
            }
            else
            {
                m_percent = ((double) m_rtmp->m_read.timestamp) / (m_duration * 1000.0) * 100.0;
                m_percent = ((double) (int) (m_percent * 10.0)) / 10.0;
                RTMP_LogPrintf("%s download at: %.3f kB / %.3f sec (%.1f%%)\n",
                               m_bResume ? "Resuming" : "Starting",
                               (double) size / 1024.0, (double) m_rtmp->m_read.timestamp / 1000.0,
                               m_percent);
            }
        }
        else
        {
            RTMP_LogPrintf("%s download at: %.3f kB\n",
                           m_bResume ? "Resuming" : "Starting",
                           (double) size / 1024.0);
        }
    }

    if(dStopOffset > 0)
        RTMP_LogPrintf("For duration: %.3f sec\n", (double) (dStopOffset - dSeek) / 1000.0);

    m_rtmp->m_read.nResumeTS = dSeek;

    now = RTMP_GetTime();
    lastUpdate = now - 1000;
    do
    {
        nRead = RTMP_Read(m_rtmp, buffer, bufferSize);
        //RTMP_LogPrintf("nRead: %d\n", nRead);
        if(nRead > 0)
        {
            if(m_destFile.isOpen())
            {
                if(m_destFile.write(buffer, nRead) != nRead)
                {
                    setError(QString("Can't write to %1 - %2").arg(m_destFile.fileName()).arg(m_destFile.errorString()));
                    m_stop = true;
                }
            }
            else
                emit readData(QByteArray(buffer, nRead));
            m_destFile.flush();
            size += nRead;
            setStreamIsRunning(true);

            //RTMP_LogPrintf("write %dbytes (%.1f kB)\n", nRead, nRead/1024.0);
            if(m_duration <= 0)	// if duration unknown try to get it from the stream (onMetaData)
                m_duration = RTMP_GetDuration(m_rtmp);

            if(m_duration > 0)
            {
                // make sure we claim to have enough buffer time!
                if(!m_bOverrideBufferTime && m_bufferTime < (m_duration * 1000.0))
                {
                    m_bufferTime = (quint32) (m_duration * 1000.0) + 5000;	// extra 5sec to make sure we've got enough

                    RTMP_Log(RTMP_LOGDEBUG, "Detected that buffer time is less than duration, resetting to: %dms", m_bufferTime);
                    RTMP_SetBufferMS(m_rtmp, m_bufferTime);
                    RTMP_UpdateBufferMS(m_rtmp);
                }
                m_percent = ((double) m_rtmp->m_read.timestamp) / (m_duration * 1000.0) * 100.0;
                m_percent = ((double) (int) (m_percent * 10.0)) / 10.0;
                now = RTMP_GetTime();
                if(abs(now - lastUpdate) > 200)
                {
                    RTMP_LogStatus("\r%.3f kB / %.2f sec (%.1f%%)",
                                   (double) size / 1024.0,
                                   (double) (m_rtmp->m_read.timestamp) / 1000.0, m_percent);
                    lastUpdate = now;
                }
            }
//.........这里部分代码省略.........

void QRtmp::run()
{
    bool first = true;
    int retries = 0;

    if(!m_destFile.fileName().isEmpty())
        if(!m_destFile.open(QIODevice::WriteOnly))
        {
            setError(QString("Can't open %1 for writing").arg(m_destFile.fileName()));
            return;
        }

    while(!m_stop)
    {
        RTMP_Log(RTMP_LOGDEBUG, "Setting buffer time to: %dms", m_bufferTime);
        RTMP_SetBufferMS(m_rtmp, m_bufferTime);

        if(first)
        {
            first = false;
            RTMP_LogPrintf("Connecting ...\n");

            if(!RTMP_Connect(m_rtmp, NULL))
            {
                setError("RTMP_Connect failed");
                break;
            }

            RTMP_Log(RTMP_LOGINFO, "Connected...");

            // User defined seek offset
            if(dStartOffset > 0)
            {
                // Don't need the start offset if resuming an existing file
                if(m_bResume)
                {
                    RTMP_Log(RTMP_LOGWARNING, "Can't seek a resumed stream, ignoring --start option");
                    dStartOffset = 0;
                }
                else
                    dSeek = dStartOffset;
            }

            // Calculate the length of the stream to still play
            if(dStopOffset > 0)
            {
                // Quit if start seek is past required stop offset
                if(dStopOffset <= dSeek)
                {
                    RTMP_LogPrintf("Already Completed\n");
                    break;
                }
            }

            if(!RTMP_ConnectStream(m_rtmp, dSeek))
            {
                setError("RTMP_ConnectStream failed");
                break;
            }
        }
        else
        {
            if(retries)
            {
                RTMP_Log(RTMP_LOGERROR, "Failed to resume the stream\n\n");
                if(!RTMP_IsTimedout(m_rtmp))
                    setError("RTMP_IsTimedout failed");
                else
                    setError("RTMP_IsTimedout RD_INCOMPLETE");
                break;
            }

            RTMP_Log(RTMP_LOGINFO, "Connection timed out, trying to resume.\n\n");

            /* Did we already try pausing, and it still didn't work? */
            if(m_rtmp->m_pausing == 3)
            {
                /* Only one try at reconnecting... */
                retries = 1;
                dSeek = m_rtmp->m_pauseStamp;
                if(dStopOffset > 0)
                {
                    if(dStopOffset <= dSeek)
                    {
                        RTMP_LogPrintf("Already Completed\n");
                        break;
                    }
                }
                if(!RTMP_ReconnectStream(m_rtmp, dSeek))
                {
                    RTMP_Log(RTMP_LOGERROR, "Failed to resume the stream\n\n");
                    if(!RTMP_IsTimedout(m_rtmp))
                        setError("RTMP_IsTimedout failed");
                    else
                        setError("RTMP_IsTimedout RD_INCOMPLETE");
                    break;
                }
            }
            else if(!RTMP_ToggleStream(m_rtmp))
            {
//.........这里部分代码省略.........