static void
tftp_recvfile(int peer, const char *mode)
{
uint16_t block;
struct timeval now1, now2;
struct tftp_stats ts;
gettimeofday(&now1, NULL);
if (debug&DEBUG_SIMPLE)
tftp_log(LOG_DEBUG, "Receiving file");
write_init(0, file, mode);
block = 0;
tftp_receive(peer, &block, &ts, NULL, 0);
write_close();
gettimeofday(&now2, NULL);
if (debug&DEBUG_SIMPLE) {
double f;
if (now1.tv_usec > now2.tv_usec) {
now2.tv_usec += 1000000;
now2.tv_sec--;
}
f = now2.tv_sec - now1.tv_sec +
(now2.tv_usec - now1.tv_usec) / 100000.0;
tftp_log(LOG_INFO,
"Download of %jd bytes in %d blocks completed after %0.1f seconds\n",
(intmax_t)ts.amount, block, f);
}
return;
}
static int write_buffer_ac3( filter_t *p_filter, block_t *p_in_buf )
{
static const size_t a52_size = A52_FRAME_NB * 4;
if( unlikely( p_in_buf->i_buffer < 6
|| p_in_buf->i_buffer > a52_size
|| p_in_buf->i_nb_samples != A52_FRAME_NB ) )
{
/* Input is not correctly packetizer. Try to parse the buffer in order
* to get the mandatory informations to play AC3 over S/PDIF */
vlc_a52_header_t a52;
if( vlc_a52_header_Parse( &a52, p_in_buf->p_buffer, p_in_buf->i_buffer )
!= VLC_SUCCESS || a52.b_eac3 || a52.i_size > p_in_buf->i_buffer )
return SPDIF_ERROR;
p_in_buf->i_buffer = a52.i_size;
p_in_buf->i_nb_samples = a52.i_samples;
}
if( p_in_buf->i_buffer + SPDIF_HEADER_SIZE > a52_size
|| write_init( p_filter, p_in_buf, a52_size, A52_FRAME_NB ) )
return SPDIF_ERROR;
write_buffer( p_filter, p_in_buf );
write_finalize( p_filter, IEC61937_AC3 |
( ( p_in_buf->p_buffer[5] & 0x7 ) << 8 ) /* bsmod */,
8 /* in bits */ );
return SPDIF_SUCCESS;
}
/* Adapted from libavformat/spdifenc.c: */
static int write_buffer_dtshd( filter_t *p_filter, block_t *p_in_buf )
{
static const char p_dtshd_start_code[10] = {
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe
};
static const size_t i_dtshd_start_code = sizeof( p_dtshd_start_code );
filter_sys_t *p_sys = p_filter->p_sys;
vlc_dts_header_t core;
if( vlc_dts_header_Parse( &core, p_in_buf->p_buffer,
p_in_buf->i_buffer ) != VLC_SUCCESS )
return SPDIF_ERROR;
unsigned i_period = p_filter->fmt_out.audio.i_rate
* core.i_frame_length / core.i_rate;
int i_subtype = dtshd_get_subtype( i_period );
if( i_subtype == -1 )
return SPDIF_ERROR;
size_t i_in_size = i_dtshd_start_code + 2 + p_in_buf->i_buffer;
size_t i_out_size = i_period * 4;
uint16_t i_data_type = IEC61937_DTSHD | i_subtype << 8;
if( p_filter->p_sys->dtshd.b_skip
|| i_in_size + SPDIF_HEADER_SIZE > i_out_size )
{
/* The bitrate is too high, pass only the core part */
p_in_buf->i_buffer = core.i_frame_size;
i_in_size = i_dtshd_start_code + 2 + p_in_buf->i_buffer;
if( i_in_size + SPDIF_HEADER_SIZE > i_out_size )
return SPDIF_ERROR;
/* Don't try to send substreams anymore. That way, we avoid to switch
* back and forth between DTD and DTS-HD */
p_filter->p_sys->dtshd.b_skip = true;
}
if( write_init( p_filter, p_in_buf, i_out_size,
i_out_size / p_filter->fmt_out.audio.i_bytes_per_frame ) )
return SPDIF_ERROR;
write_data( p_filter, p_dtshd_start_code, i_dtshd_start_code, true );
write_16( p_filter, p_in_buf->i_buffer );
write_buffer( p_filter, p_in_buf );
/* Align so that (length_code & 0xf) == 0x8. This is reportedly needed
* with some receivers, but the exact requirement is unconfirmed. */
#define ALIGN(x, y) (((x) + ((y) - 1)) & ~((y) - 1))
size_t i_align = ALIGN( i_in_size + 0x8, 0x10 ) - 0x8;
#undef ALIGN
if( i_align > i_in_size && i_align - i_in_size
<= p_sys->p_out_buf->i_buffer - p_sys->i_out_offset )
write_padding( p_filter, i_align - i_in_size );
write_finalize( p_filter, i_data_type, 1 /* in bytes */ );
return SPDIF_SUCCESS;
}
bool PNGWriter::Write(const float* buffer)
{
if (!write_init())
return false;
write_header();
write_bytes(reinterpret_cast<const unsigned char*>(buffer));
if (!write_end())
return false;
return true;
}
bool PNGWriter::Write(const unsigned char* buffer)
{
if (!write_init())
return false;
write_header();
write_bytes(buffer);
if (!write_end())
return false;
return true;
}
static int write_buffer_dts( filter_t *p_filter, block_t *p_in_buf )
{
uint16_t i_data_type;
/* Only send the DTS core part */
vlc_dts_header_t core;
if( vlc_dts_header_Parse( &core, p_in_buf->p_buffer,
p_in_buf->i_buffer ) != VLC_SUCCESS )
return SPDIF_ERROR;
p_in_buf->i_nb_samples = core.i_frame_length;
p_in_buf->i_buffer = core.i_frame_size;
switch( p_in_buf->i_nb_samples )
{
case 512:
i_data_type = IEC61937_DTS1;
break;
case 1024:
i_data_type = IEC61937_DTS2;
break;
case 2048:
i_data_type = IEC61937_DTS3;
break;
default:
msg_Err( p_filter, "Frame size %d not supported",
p_in_buf->i_nb_samples );
return SPDIF_ERROR;
}
if( p_in_buf->i_buffer == p_in_buf->i_nb_samples * 4 )
{
/* No enough room to put the S/PDIF header. This is the case for DTS
* inside WAV. */
i_data_type = 0;
}
else if( p_in_buf->i_buffer + SPDIF_HEADER_SIZE > p_in_buf->i_nb_samples * 4 )
return SPDIF_ERROR;
if( write_init( p_filter, p_in_buf, p_in_buf->i_nb_samples * 4,
p_in_buf->i_nb_samples ) )
return SPDIF_ERROR;
if( i_data_type == 0 )
p_filter->p_sys->i_out_offset = 0;
write_buffer( p_filter, p_in_buf );
write_finalize( p_filter, i_data_type, 8 /* in bits */ );
return SPDIF_SUCCESS;
}
int main(int argc, char **argv)
{
int opt;
while ((opt = getopt(argc, argv, "c:fhr")) != -1) {
switch (opt) {
case 'c':
config = optarg;
break;
case 'f':
use_dsp = false;
break;
case 'r':
use_dsp = false;
write_raw = true;
break;
case 'h': /* fallthrough */
default:
print_help(argv[0]);
exit(1);
}
}
if (argc == optind + 2) {
write_init(argv[optind + 1]);
} else if (argc == optind + 1) {
if (!use_dsp) {
fprintf(stderr, "error: -r can't be used for playback\n");
print_help(argv[0]);
exit(1);
}
core_allocator_init();
playback_init();
} else {
if (argc > 1)
fprintf(stderr, "error: wrong number of arguments\n");
print_help(argv[0]);
exit(1);
}
decode_file(argv[optind]);
if (mode == MODE_WRITE)
write_quit();
else if (mode == MODE_PLAY)
playback_quit();
return 0;
}
static int write_buffer_eac3( filter_t *p_filter, block_t *p_in_buf )
{
filter_sys_t *p_sys = p_filter->p_sys;
vlc_a52_header_t a52 = { };
if( vlc_a52_header_Parse( &a52, p_in_buf->p_buffer, p_in_buf->i_buffer )
!= VLC_SUCCESS || a52.i_size > p_in_buf->i_buffer )
return SPDIF_ERROR;
p_in_buf->i_buffer = a52.i_size;
p_in_buf->i_nb_samples = a52.i_samples;
if( !p_sys->p_out_buf
&& write_init( p_filter, p_in_buf, AOUT_SPDIF_SIZE * 4, AOUT_SPDIF_SIZE ) )
return SPDIF_ERROR;
if( p_in_buf->i_buffer > p_sys->p_out_buf->i_buffer - p_sys->i_out_offset )
return SPDIF_ERROR;
write_buffer( p_filter, p_in_buf );
if( a52.b_eac3 )
{
if( ( a52.eac3.strmtyp == EAC3_STRMTYP_INDEPENDENT
|| a52.eac3.strmtyp == EAC3_STRMTYP_AC3_CONVERT )
&& a52.i_blocks_per_sync_frame != 6 )
{
/* cf. Annex E 2.3.1.2 of AC3 spec */
if( a52.eac3.i_substreamid == 0 )
p_sys->eac3.i_nb_blocks_substream0
+= a52.i_blocks_per_sync_frame;
if( p_sys->eac3.i_nb_blocks_substream0 != 6 )
return SPDIF_MORE_DATA;
else
p_sys->eac3.i_nb_blocks_substream0 = 0;
}
write_finalize( p_filter, IEC61937_EAC3, 1 /* in bytes */ );
return SPDIF_SUCCESS;
}
else
return SPDIF_MORE_DATA;
}
int main(int argc, char** argv) {
int c;
while ((c = getopt(argc, argv, "v:")) != -1) {
switch (c) {
case 'v':
verbose = atoi(optarg);
break;
default:
usage(argv[0]);
}
}
if (optind != argc-1)
usage(argv[0]);
char* display = argv[optind];
trueorabort(display[0] == ':', "Invalid display: '%s'", display);
char* endptr;
int displaynum = (int)strtol(display+1, &endptr, 10);
trueorabort(display+1 != endptr && (*endptr == '\0' || *endptr == '.'),
"Invalid display number: '%s'", display);
init_display(display);
socket_server_init(PORT_BASE + displaynum);
unsigned char buffer[BUFFERSIZE];
int length;
while (1) {
set_connected(dpy, False);
socket_server_accept(VERSION);
write_init();
set_connected(dpy, True);
while (1) {
length = socket_client_read_frame((char*)buffer, sizeof(buffer));
if (length < 0) {
socket_client_close(1);
break;
}
if (length < 1) {
error("Invalid packet from client (size <1).");
socket_client_close(0);
break;
}
switch (buffer[0]) {
case 'S': /* Screen */
if (!check_size(length, sizeof(struct screen), "screen"))
break;
write_image((struct screen*)buffer);
break;
case 'P': /* Cursor */
if (!check_size(length, sizeof(struct cursor), "cursor"))
break;
write_cursor();
break;
case 'R': /* Resolution */
if (!check_size(length, sizeof(struct resolution),
"resolution"))
break;
change_resolution((struct resolution*)buffer);
break;
case 'K': { /* Key */
if (!check_size(length, sizeof(struct key), "key"))
break;
struct key* k = (struct key*)buffer;
log(2, "Key: kc=%04x\n", k->keycode);
XTestFakeKeyEvent(dpy, k->keycode, k->down, CurrentTime);
if (k->down) {
kb_add(KEYBOARD, k->keycode);
} else {
kb_remove(KEYBOARD, k->keycode);
}
break;
}
case 'C': { /* Click */
if (!check_size(length, sizeof(struct mouseclick),
"mouseclick"))
break;
struct mouseclick* mc = (struct mouseclick*)buffer;
XTestFakeButtonEvent(dpy, mc->button, mc->down, CurrentTime);
if (mc->down) {
kb_add(MOUSE, mc->button);
} else {
kb_remove(MOUSE, mc->button);
}
break;
}
case 'M': { /* Mouse move */
if (!check_size(length, sizeof(struct mousemove), "mousemove"))
break;
struct mousemove* mm = (struct mousemove*)buffer;
XTestFakeMotionEvent(dpy, 0, mm->x, mm->y, CurrentTime);
break;
}
case 'Q': /* "Quit": release all keys */
kb_release_all();
break;
default:
error("Invalid packet from client (%d).", buffer[0]);
socket_client_close(0);
}
}
socket_client_close(0);
kb_release_all();
close_mmap(&cache[0]);
close_mmap(&cache[1]);
}
return 0;
}
/*
* Receive a file.
*/
void
recvfile(int peer, char *port, int fd, char *name, char *mode)
{
struct tftphdr *rp;
uint16_t block;
char recvbuffer[MAXPKTSIZE];
int n, i;
struct tftp_stats tftp_stats;
stats_init(&tftp_stats);
rp = (struct tftphdr *)recvbuffer;
if (port == NULL) {
struct servent *se;
se = getservbyname("tftp", "udp");
((struct sockaddr_in *)&peer_sock)->sin_port = se->s_port;
} else
((struct sockaddr_in *)&peer_sock)->sin_port =
htons(atoi(port));
for (i = 0; i < 12; i++) {
struct sockaddr_storage from;
/* Tell the other side what we want to do */
if (debug&DEBUG_SIMPLE)
printf("Requesting %s\n", name);
n = send_rrq(peer, name, mode);
if (n > 0) {
printf("Cannot send RRQ packet\n");
return;
}
/*
* The first packet we receive has the new destination port
* we have to send the next packets to.
*/
n = receive_packet(peer, recvbuffer,
MAXPKTSIZE, &from, timeoutpacket);
/* We got something useful! */
if (n >= 0) {
((struct sockaddr_in *)&peer_sock)->sin_port =
((struct sockaddr_in *)&from)->sin_port;
break;
}
/* We should retry if this happens */
if (n == RP_TIMEOUT) {
printf("Try %d, didn't receive answer from remote.\n",
i + 1);
continue;
}
/* Otherwise it is a fatal error */
break;
}
if (i == 12) {
printf("Transfer timed out.\n");
return;
}
if (rp->th_opcode == ERROR) {
tftp_log(LOG_ERR, "Error code %d: %s", rp->th_code, rp->th_msg);
return;
}
if (write_init(fd, NULL, mode) < 0) {
warn("write_init");
return;
}
/*
* If the first packet is an OACK packet instead of an DATA packet,
* handle it different.
*/
if (rp->th_opcode == OACK) {
if (!options_rfc_enabled) {
printf("Got OACK while options are not enabled!\n");
send_error(peer, EBADOP);
return;
}
parse_options(peer, rp->th_stuff, n + 2);
n = send_ack(peer, 0);
if (n > 0) {
printf("Cannot send ACK on OACK.\n");
return;
}
block = 0;
tftp_receive(peer, &block, &tftp_stats, NULL, 0);
} else {
block = 1;
tftp_receive(peer, &block, &tftp_stats, rp, n);
}
write_close();
if (tftp_stats.amount > 0)
printstats("Received", verbose, &tftp_stats);
return;
}
int main(int argc, char* argv[]){
// parsing the arguments
if(argc < 3)
error_exit("Syntax error : Incorrect arguments, use : input_file output_file [-v] [-m filename].\r\n\r\n");
bool use_verbatim = false;
FILE* matlab_file = NULL;
FILE* input_file = fopen(argv[1],"r");
FILE* output_file = fopen(argv[2],"w+");
if( input_file == NULL || output_file == NULL)
error_exit("Runtime error : could not open required i/o files.\r\n\r\n");
for(int i=3 ; i < argc; i++){
if( argv[i][0] != '-' )
error_exit("Syntax error : Unknown parameter : %s\r\n\r\n",argv[i]);
switch(argv[i][1]){
case 'v' :
use_verbatim = true;
break;
case 'm' :
if(i+1 >= argc)
error_exit("Syntax error : Filename required with -m option\r\n\r\n");
matlab_file = fopen(argv[i+1], "w+");
if(matlab_file == NULL)
error_exit("Runtime error : Cannot open file '%s' for matlab output.\r\n\r\n",argv[i+1]);
i++;
break;
}
}
// positions and speed at time n-1 (0) and n (1).
vector p10,p20,v1,v2,p11,p21;
// masses
long double m1,m2;
// discretization parameters
long double dt, t_final, dt_output;
fscanf(input_file, "%Lf\r\n%Lf %Lf %Lf\r\n%Lf %Lf %Lf\r\n%Lf\r\n%Lf %Lf %Lf\r\n%Lf %Lf %Lf\r\n%Lf\r\n%Lf\r\n%Lf", &m1, &(p10.x), &(p10.y), &(p10.z), &(v1.x), &(v1.y), &(v1.z), &m2, &(p20.x), &(p20.y), &(p20.z), &(v2.x), &(v2.y), &(v2.z), &dt, &t_final, &dt_output );
// Initial values determination
p11 = addv(scalev(v1, dt), p10);
p21 = addv(scalev(v2, dt), p20);
write_init(output_file, matlab_file, use_verbatim, m1, p10, v1, m2, p20, v2, dt, t_final, dt_output);
write_output(output_file, matlab_file, use_verbatim, 0, p10, p20);
if(dt_output <= dt + DOUBLE_EPSILON) write_output(output_file, matlab_file, use_verbatim, dt, p11, p21);
long double next_out = dt_output;
for(long double t = dt * 2 ; t <= t_final ; t+= dt ){
vector dp = subv(p21,p11);
long double norm = normv(dp);
// compute F
vector f = scalev(dp, - m1 * m2 * CONST_G / (norm * norm * norm));
// compute positions at time t
vector new_p1 = addv(subv(scalev(f, - dt * dt / m1), p10) , scalev(p11, 2));
vector new_p2 = addv(subv(scalev(f, dt * dt / m2), p20) , scalev(p21, 2));
p10 = p11;
p20 = p21;
p11 = new_p1;
p21 = new_p2;
if(t + dt - DOUBLE_EPSILON >= next_out){
write_output(output_file, matlab_file, use_verbatim, t, p11, p21);
next_out +=dt_output;
}
}
write_end(output_file, matlab_file, use_verbatim);
fclose(input_file);
fclose(output_file);
return EXIT_SUCCESS;
}
/* Adapted from libavformat/spdifenc.c:
* It seems Dolby TrueHD frames have to be encapsulated in MAT frames before
* they can be encapsulated in IEC 61937.
* Here we encapsulate 24 TrueHD frames in a single MAT frame, padding them
* to achieve constant rate.
* The actual format of a MAT frame is unknown, but the below seems to work.
* However, it seems it is not actually necessary for the 24 TrueHD frames to
* be in an exact alignment with the MAT frame
*/
static int write_buffer_truehd( filter_t *p_filter, block_t *p_in_buf )
{
#define TRUEHD_FRAME_OFFSET 2560
filter_sys_t *p_sys = p_filter->p_sys;
if( !p_sys->p_out_buf
&& write_init( p_filter, p_in_buf, 61440, 61440 / 16 ) )
return SPDIF_ERROR;
int i_padding = 0;
if( p_sys->truehd.i_frame_count == 0 )
{
static const char p_mat_start_code[20] = {
0x07, 0x9E, 0x00, 0x03, 0x84, 0x01, 0x01, 0x01, 0x80, 0x00,
0x56, 0xA5, 0x3B, 0xF4, 0x81, 0x83, 0x49, 0x80, 0x77, 0xE0
};
write_data( p_filter, p_mat_start_code, 20, true );
/* We need to include the S/PDIF header in the first MAT frame */
i_padding = TRUEHD_FRAME_OFFSET - p_in_buf->i_buffer - 20
- SPDIF_HEADER_SIZE;
}
else if( p_sys->truehd.i_frame_count == 11 )
{
/* The middle mat code need to be at the ((2560 * 12) - 4) offset */
i_padding = TRUEHD_FRAME_OFFSET - p_in_buf->i_buffer - 4;
}
else if( p_sys->truehd.i_frame_count == 12 )
{
static const char p_mat_middle_code[12] = {
0xC3, 0xC1, 0x42, 0x49, 0x3B, 0xFA,
0x82, 0x83, 0x49, 0x80, 0x77, 0xE0
};
write_data( p_filter, p_mat_middle_code, 12, true );
i_padding = TRUEHD_FRAME_OFFSET - p_in_buf->i_buffer - ( 12 - 4 );
}
else if( p_sys->truehd.i_frame_count == 23 )
{
static const char p_mat_end_code[16] = {
0xC3, 0xC2, 0xC0, 0xC4, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x97, 0x11
};
/* The end mat code need to be at the ((2560 * 24) - 24) offset */
i_padding = TRUEHD_FRAME_OFFSET - p_in_buf->i_buffer - 24;
if( i_padding < 0 || p_in_buf->i_buffer + i_padding >
p_sys->p_out_buf->i_buffer - p_sys->i_out_offset )
return SPDIF_ERROR;
write_buffer( p_filter, p_in_buf );
write_padding( p_filter, i_padding );
write_data( p_filter, p_mat_end_code, 16, true );
write_finalize( p_filter, IEC61937_TRUEHD, 1 /* in bytes */ );
p_sys->truehd.i_frame_count = 0;
return SPDIF_SUCCESS;
}
else
i_padding = TRUEHD_FRAME_OFFSET - p_in_buf->i_buffer;
if( i_padding < 0 || p_in_buf->i_buffer + i_padding >
p_sys->p_out_buf->i_buffer - p_sys->i_out_offset )
return SPDIF_ERROR;
write_buffer( p_filter, p_in_buf );
write_padding( p_filter, i_padding );
p_sys->truehd.i_frame_count++;
return SPDIF_MORE_DATA;
}
