void
 RTMPSession::sendConnectPacket()
 {
     RTMPChunk_0 metadata = {{0}};
     metadata.msg_stream_id = kControlChannelStreamId;
     metadata.msg_type_id = RTMP_PT_INVOKE;
     std::vector<uint8_t> buff;
     std::stringstream url ;
     if(m_uri.port > 0) {
         url << m_uri.protocol << "://" << m_uri.host << ":" << m_uri.port << "/" << m_app;
     } else {
         url << m_uri.protocol << "://" << m_uri.host << "/" << m_app;
     }
     put_string(buff, "connect");
     put_double(buff, ++m_numberOfInvokes);
     m_trackedCommands[m_numberOfInvokes] = "connect";
     put_byte(buff, kAMFObject);
     put_named_string(buff, "app", m_app.c_str());
     put_named_string(buff,"type", "nonprivate");
     put_named_string(buff, "tcUrl", url.str().c_str());
     put_named_bool(buff, "fpad", false);
     put_named_double(buff, "capabilities", 15.);
     put_named_double(buff, "audioCodecs", 10. );
     put_named_double(buff, "videoCodecs", 7.);
     put_named_double(buff, "videoFunction", 1.);
     put_be16(buff, 0);
     put_byte(buff, kAMFObjectEnd);
     
     metadata.msg_length.data = static_cast<int>( buff.size() );
     sendPacket(&buff[0], buff.size(), metadata);
 }
 void
 RTMPSession::sendDeleteStream()
 {
     RTMPChunk_0 metadata = {{0}};
     metadata.msg_stream_id = kControlChannelStreamId;
     metadata.msg_type_id = RTMP_PT_INVOKE;
     std::vector<uint8_t> buff;
     put_string(buff, "deleteStream");
     put_double(buff, ++m_numberOfInvokes);
     m_trackedCommands[m_numberOfInvokes] = "deleteStream";
     put_byte(buff, kAMFNull);
     put_double(buff, m_streamId);
     
     metadata.msg_length.data = static_cast<int>( buff.size() );
     
     sendPacket(&buff[0], buff.size(), metadata);
     
 }
 void
 RTMPSession::sendPublish()
 {
     RTMPChunk_0 metadata = {{0}};
     metadata.msg_stream_id = kAudioChannelStreamId;
     metadata.msg_type_id = RTMP_PT_INVOKE;
     std::vector<uint8_t> buff;
     std::vector<uint8_t> chunk;
     
     put_string(buff, "publish");
     put_double(buff, ++m_numberOfInvokes);
     m_trackedCommands[m_numberOfInvokes] = "publish";
     put_byte(buff, kAMFNull);
     put_string(buff, m_playPath);
     put_string(buff, "live");
     metadata.msg_length.data = static_cast<int>( buff.size() );
     
     sendPacket(&buff[0], buff.size(), metadata);
 }
static void
put_value (Sophon_VM *vm, Sophon_IOFunc func, Sophon_Ptr data,
			Sophon_Value v)
{
	if (sophon_value_is_undefined(v)) {
		put_u8(func, data, TAG_UNDEF);
	} else if (sophon_value_is_null(v)) {
		put_u8(func, data, TAG_NULL);
	} else if (sophon_value_is_bool(v)) {
		Sophon_Bool b;

		b = sophon_value_to_bool(vm, v);
		put_u8(func, data, TAG_BOOL);
		put_u8(func, data, b ? 1 : 0);
	} else if (sophon_value_is_string(v)) {
		Sophon_String *str;

		sophon_value_to_string(vm, v, &str);
		put_u8(func, data, (str->gc_flags & SOPHON_GC_FL_INTERN) ?
					TAG_INTERN_STRING : TAG_STRING);
		put_str(vm, func, data, str);
	} else if (sophon_value_is_number(v)) {
		Sophon_Number n;

		sophon_value_to_number(vm, v, &n);

		if (n == (Sophon_Number)(Sophon_Int)(n)) {
			put_u8(func, data, TAG_INT);
			put_u32(func, data, (Sophon_Int)n);
		} else {
			put_u8(func, data, TAG_DOUBLE);
			put_double(func, data, n);
		}
	} else {
		SOPHON_ASSERT(0);
	}
}
Exemple #5
0
void long_flo(value *sp) {
     put_double(sp, get_long(sp));
}
Exemple #6
0
static void geninittype P2 (const EXPR *, ep, unsigned char *, data)
{
    TYP    *tp = ep->etp;
    UVAL    uval;

    
#ifdef FLOAT_SUPPORT
    RVAL    rvl;

    
#endif /* FLOAT_SUPPORT */
	UNUSEDARG (data);
    switch (tp->type) {
    case bt_bool:
	put_char (ep);
	break;
    case bt_char:
    case bt_charu:
    case bt_uchar:
    case bt_schar:
	put_char (ep);
	break;
    case bt_short:
    case bt_ushort:
    case bt_int16:
    case bt_uint16:
	put_short (ep);
	break;
    case bt_pointer16:
    case bt_pointer32:
	break;
    case bt_bitfield:
    case bt_ubitfield:
    case bt_bbitfield:
	uval = ep->v.u & bitmask (bitfield_width (tp));
	break;
    case bt_int32:
    case bt_uint32:
    case bt_ulong:
    case bt_long:
	put_long (ep);
	break;
    case bt_struct:
	break;
    case bt_union:
	break;
	
#ifdef FLOAT_SUPPORT
    case bt_float:
	floatexpr (tp, &rvl);
	put_float (&rvl);
	break;
    case bt_double:
	floatexpr (tp, &rvl);
	put_double (&rval);
	break;
    case bt_longdouble:
	floatexpr (tp, &rvl);
	put_longdouble (&rvl);
	break;
	
#endif /* FLOAT_SUPPORT */
    case bt_func:
	break;
    default:
	break;
    }
}
Exemple #7
0
int main(int argc, char **argv)
{
	int i;
	int force = 1;

	/* parse the options first */
	for(i = 1; i < argc; i++)
	{
		if(argv[i][0] == '-')
		{
			if(argv[i][1] == '-')
			{
				/* continue parsing filenames */
				force = i + 1;
				break;
			}

			else if(strcmp(argv[i], "-h") == 0)
			{
				fprintf(stdout, "Usage: %s [-h] [-f]\n-h: display this help message\n-f: force overwriting\n", argv[0]);
				return 1;
			}
			else if(strcmp(argv[i], "-f") == 0)
			{
				m_force = 1;
			}
			else
			{
				fprintf(stderr, "Unrecognized option: '%s'\n", argv[i]);
				return 1;
			}
		}
	}

	/* parse the filenames */
	for(i = force; i < argc; i++)
	{
		if(force > 1 || argv[i][0] != '-')
		{
			if(!compile(argv[i]))
			{
				fprintf(stderr, "Error compiling map '%s'\n", argv[i]);
				return 1;
			}
		}
	}

	if(0)
	{
		/* unused function warning */
		put_double(NULL, NULL);
		put_float(NULL, NULL);
		put_int(NULL, NULL);
		put_short(NULL, NULL);
		put_char(NULL, NULL);
		put_cdouble(NULL, 0);
		put_cfloat(NULL, 0);
		put_cint(NULL, 0);
		put_cshort(NULL, 0);
		put_cchar(NULL, 0);
		put_str(NULL, NULL, 0);
	}

	return 0;
}
Exemple #8
0
int write_test1(TEST_DATA *data, IO_BUFFER *iobuf)
{
   IO_ITEM_HEADER item_header;
   int i;
   
   item_header.type = 99;             /* test data */
   item_header.version = 0;          /* Version 0 (test) */
   item_header.ident = 123;
   
   put_item_begin(iobuf,&item_header);

   put_long(data->lvar[0],iobuf);
   put_long(data->lvar[1],iobuf);
   put_long((long)data->ilvar[0],iobuf);
   put_long((long)data->ilvar[1],iobuf);
   put_short(data->isvar[0],iobuf);
   put_short(data->isvar[1],iobuf);
   put_short(data->svar[0],iobuf);
   put_short(data->svar[1],iobuf);
   put_short(data->svar[2],iobuf);
   put_real(data->fvar[0],iobuf);
   put_real(data->fvar[1],iobuf);
   put_double(data->dvar[0],iobuf);
   put_double(data->dvar[1],iobuf);
   put_sfloat(data->hvar[0],iobuf);
   put_sfloat(data->hvar[1],iobuf);
   put_byte(data->i8var[0],iobuf);
   put_byte(data->i8var[1],iobuf);
   put_byte(data->u8var[0],iobuf);
   put_byte(data->u8var[1],iobuf);
   put_short(data->i16var[0],iobuf);
   put_short(data->i16var[1],iobuf);
   put_short(data->u16var[0],iobuf);
   put_short(data->u16var[1],iobuf);
   put_int32(data->i32var[0],iobuf);
   put_int32(data->i32var[1],iobuf);
   put_uint32(data->u32var[0],iobuf);
   put_uint32(data->u32var[1],iobuf);
#ifdef HAVE_64BIT_INT
   put_vector_of_int64(&data->i64var[0],1,iobuf);
   put_vector_of_int64(&data->i64var[1],1,iobuf);
   put_vector_of_uint64(&data->u64var[0],1,iobuf);
   put_vector_of_uint64(&data->u64var[1],1,iobuf);
#endif   
   put_count(data->nbvar,iobuf);
   put_byte(data->bvar[0],iobuf);
   put_byte(data->bvar[1],iobuf);
   for (i=0; i<4; i++)
      put_count16(data->cnt16var[i],iobuf);
   for (i=0; i<6; i++)
      put_count32(data->cnt32var[i],iobuf);
   for (i=0; i<6; i++)
      put_count(data->cntzvar[i],iobuf);
   for (i=0; i<8; i++)
      put_count(data->cntvar[i],iobuf);
   for (i=0; i<10; i++)
      put_scount16(data->scnt16var[i],iobuf);
   for (i=0; i<12; i++)
      put_scount32(data->scnt32var[i],iobuf);
   for (i=0; i<12; i++)
      put_scount(data->scntzvar[i],iobuf);
   for (i=0; i<14; i++)
      put_scount(data->scntvar[i],iobuf);
   put_string(data->str16var,iobuf);
   put_long_string(data->str32var,iobuf);
   put_var_string(data->strvvar,iobuf);
   return(put_item_end(iobuf,&item_header));
}
Exemple #9
0
CORBA_boolean 
porbit_put_sv (GIOPSendBuffer *buf, CORBA_TypeCode tc, SV *sv)
{
    switch (tc->kind) {
    case CORBA_tk_null:
    case CORBA_tk_void:
        return CORBA_TRUE;
    case CORBA_tk_short:
	return put_short (buf, sv);
    case CORBA_tk_long:
	return put_long (buf, sv);
    case CORBA_tk_ushort:
	return put_ushort (buf, sv);
    case CORBA_tk_ulong:
	return put_ulong (buf, sv);
    case CORBA_tk_float:
	return put_float (buf, sv);
    case CORBA_tk_double:
	return put_double (buf, sv);
    case CORBA_tk_char:
	return put_char (buf, sv);
    case CORBA_tk_boolean:
	return put_boolean (buf, sv);
    case CORBA_tk_octet:
	return put_octet (buf, sv);
    case CORBA_tk_enum:
	return put_enum (buf, tc, sv);
    case CORBA_tk_struct:
	return put_struct (buf, tc, sv);
    case CORBA_tk_sequence:
	return put_sequence (buf, tc, sv);
    case CORBA_tk_except:
	return put_except (buf, tc, sv);
    case CORBA_tk_objref:
	return put_objref (buf, tc, sv);
    case CORBA_tk_union:
	return put_union (buf, tc, sv);
    case CORBA_tk_alias:
	return put_alias (buf, tc, sv);
    case CORBA_tk_string:
	return put_string (buf, tc, sv);
    case CORBA_tk_array:
	return put_array (buf, tc, sv);
    case CORBA_tk_longlong:
	return put_longlong (buf, sv);
    case CORBA_tk_ulonglong:
	return put_ulonglong (buf, sv);
    case CORBA_tk_longdouble:
	return put_longdouble (buf, sv);
    case CORBA_tk_TypeCode:
	return put_typecode (buf, tc, sv);
    case CORBA_tk_any:
	return put_any (buf, tc, sv);
    case CORBA_tk_fixed:
	return put_fixed (buf, tc, sv);
    case CORBA_tk_wchar:
    case CORBA_tk_wstring:
    case CORBA_tk_Principal:
    default:
	warn ("Unsupported output typecode %d\n", tc->kind);
	return CORBA_FALSE;
    }
}