/* tcp related */
int
nbr_osdep_tcp_str2addr(const char *str, void *addr, int *len)
{
char addr_buf[256], url_buf[256];
U16 port;
struct hostent *hp;
struct sockaddr_in *sa = (struct sockaddr_in *)addr;
if (*len < sizeof(*sa)) {
OSDEP_ERROUT(INFO,INVAL,"addrlen %d not enough %d required",
*len, sizeof(*sa));
return LASTERR;
}
*len = sizeof(*sa);
if (nbr_str_parse_url(str, sizeof(addr_buf), addr_buf, &port, url_buf) < 0) {
OSDEP_ERROUT(INFO,INVAL,"addr (%s) invalid", str);
return LASTERR;
}
if ((hp = gethostbyname(addr_buf)) == NULL) {
OSDEP_ERROUT(INFO,HOSTBYNAME,"addr (%s) invalid", addr_buf);
return LASTERR;
}
sa->sin_family = AF_INET;
sa->sin_addr.s_addr = GET_32(hp->h_addr);
sa->sin_port = htons(port);
// TRACE("str2addr: %08x,%u,%u\n", sa->sin_addr.s_addr, sa->sin_port, *len);
// ASSERT(sa->sin_addr.s_addr == 0 || sa->sin_addr.s_addr == 0x0100007f);
return *len;
}
static int mpv_process_frame(struct frame *f, void *d)
{
struct rtp_mpv *out = (struct rtp_mpv *)d;
int flen, start, in_picture = 0, have_vsh = 0;
unsigned int start_code;
out->blk_count = 0;
for (start = 0; start < f->length; start += flen) {
if (out->blk_count == 48) {
spook_log(SL_WARN,
"rtp-mpv: too many elements to send");
break;
}
flen = find_next_code(f->d + start, f->length - start);
if (flen == 0) flen = f->length - start;
start_code = GET_32(f->d + start);
if (start_code <= 0x000001AF || start_code == 0x000001B8)
in_picture = 1;
if (in_picture) {
if (start_code == 0x00000100)
parse_picture_header(out, f->d + start, flen);
out->blk[out->blk_count].d = f->d + start;
out->blk[out->blk_count].len = flen;
++out->blk_count;
}
else { /* we have not seen a GOP or picture start code yet */
if (start_code == 0x000001B3) {
out->vsh_len = 0;
have_vsh = 1;
parse_video_sequence_header(out,
f->d + start, flen);
}
if (have_vsh) {
memcpy(out->vsh + out->vsh_len,
f->d + start, flen);
out->vsh_len += flen;
}
}
}
return out->init_done;
}
static xmms_wave_format_t
read_wave_header (xmms_wave_data_t *data, guint8 *buf, gint bytes_read)
{
gchar stmp[5];
guint32 tmp32, data_size;
guint16 tmp16;
gint bytes_left = bytes_read;
xmms_wave_format_t ret = WAVE_FORMAT_UNDEFINED;
if (bytes_left < WAVE_HEADER_MIN_SIZE) {
xmms_log_error ("Not enough data for wave header");
return ret;
}
GET_STR (buf, stmp, 4);
if (strcmp (stmp, "RIFF")) {
xmms_log_error ("No RIFF data");
return ret;
}
GET_32 (buf, data_size);
data_size += 8;
GET_STR (buf, stmp, 4);
if (strcmp (stmp, "WAVE")) {
xmms_log_error ("No Wave data");
return ret;
}
GET_STR (buf, stmp, 4);
if (strcmp (stmp, "fmt ")) {
xmms_log_error ("Format chunk missing");
return ret;
}
GET_32 (buf, tmp32); /* format chunk length */
XMMS_DBG ("format chunk length: %i", tmp32);
GET_16 (buf, tmp16); /* format tag */
ret = tmp16;
switch (tmp16) {
case WAVE_FORMAT_PCM:
if (tmp32 != 16) {
xmms_log_error ("Format chunk length not 16.");
return WAVE_FORMAT_UNDEFINED;
}
GET_16 (buf, data->channels);
XMMS_DBG ("channels %i", data->channels);
if (data->channels < 1 || data->channels > 2) {
xmms_log_error ("Unhandled number of channels: %i",
data->channels);
return WAVE_FORMAT_UNDEFINED;
}
GET_32 (buf, data->samplerate);
XMMS_DBG ("samplerate %i", data->samplerate);
if (data->samplerate != 8000 && data->samplerate != 11025 &&
data->samplerate != 22050 && data->samplerate != 44100) {
xmms_log_error ("Invalid samplerate: %i", data->samplerate);
return WAVE_FORMAT_UNDEFINED;
}
GET_32 (buf, tmp32);
GET_16 (buf, tmp16);
GET_16 (buf, data->bits_per_sample);
XMMS_DBG ("bits per sample %i", data->bits_per_sample);
if (data->bits_per_sample != 8 && data->bits_per_sample != 16) {
xmms_log_error ("Unhandled bits per sample: %i",
data->bits_per_sample);
return WAVE_FORMAT_UNDEFINED;
}
break;
case WAVE_FORMAT_MP3:
SKIP (tmp32 - sizeof (tmp16));
/* set up so that seeking works with "bytes" as seek unit */
data->bits_per_sample = 8;
data->channels = 1;
break;
default:
xmms_log_error ("unhandled format tag: 0x%x", tmp16);
return WAVE_FORMAT_UNDEFINED;
}
GET_STR (buf, stmp, 4);
while (strcmp (stmp, "data")) {
GET_32 (buf, tmp32);
if (bytes_left < (tmp32 + 8)) {
xmms_log_error ("Data chunk missing");
return WAVE_FORMAT_UNDEFINED;
}
buf += tmp32;
bytes_left -= tmp32;
GET_STR (buf, stmp, 4);
}
GET_32 (buf, data->bytes_total);
data->header_size = bytes_read - bytes_left;
if (data->bytes_total + data->header_size != data_size) {
xmms_log_info ("Data chunk size doesn't match RIFF chunk size");
/* don't return FALSE here, we try to read it anyway */
}
return ret;
}
int
main(int ac, char **av)
{
int fd, n, i;
unsigned long ph, ps, np;
long nnote, nnote2, ns;
if (ac != 2) {
fprintf(stderr, "Usage: %s elf-file\n", av[0]);
exit(1);
}
fd = open(av[1], O_RDWR);
if (fd < 0) {
perror(av[1]);
exit(1);
}
nnote = 12 + ROUNDUP(strlen(arch) + 1) + sizeof(descr);
nnote2 = 12 + ROUNDUP(strlen(rpaname) + 1) + sizeof(rpanote);
n = read(fd, buf, sizeof(buf));
if (n < 0) {
perror("read");
exit(1);
}
if (memcmp(&buf[E_IDENT+EI_MAGIC], elf_magic, 4) != 0)
goto notelf;
e_class = buf[E_IDENT+EI_CLASS];
if (e_class != ELFCLASS32 && e_class != ELFCLASS64)
goto notelf;
e_data = buf[E_IDENT+EI_DATA];
if (e_data != ELFDATA2MSB && e_data != ELFDATA2LSB)
goto notelf;
if (n < E_HSIZE)
goto notelf;
ph = (e_class == ELFCLASS32 ? GET_32(E_PHOFF) : GET_64(E_PHOFF));
ps = GET_16(E_PHENTSIZE);
np = GET_16(E_PHNUM);
if (ph < E_HSIZE || ps < PH_HSIZE || np < 1)
goto notelf;
if (ph + (np + 2) * ps + nnote + nnote2 > n)
goto nospace;
for (i = 0; i < np; ++i) {
if (GET_32(ph + PH_TYPE) == PT_NOTE) {
fprintf(stderr, "%s already has a note entry\n",
av[1]);
exit(0);
}
ph += ps;
}
/* XXX check that the area we want to use is all zeroes */
for (i = 0; i < 2 * ps + nnote + nnote2; ++i)
if (buf[ph + i] != 0)
goto nospace;
/* fill in the program header entry */
ns = ph + 2 * ps;
PUT_32(ph + PH_TYPE, PT_NOTE);
if (e_class == ELFCLASS32)
PUT_32(ph + PH_OFFSET, ns);
else
PUT_64(ph + PH_OFFSET, ns);
if (e_class == ELFCLASS32)
PUT_32(ph + PH_FILESZ, nnote);
else
PUT_64(ph + PH_FILESZ, nnote);
/* fill in the note area we point to */
/* XXX we should probably make this a proper section */
PUT_32(ns, strlen(arch) + 1);
PUT_32(ns + 4, N_DESCR * 4);
PUT_32(ns + 8, 0x1275);
strcpy((char *) &buf[ns + 12], arch);
ns += 12 + strlen(arch) + 1;
for (i = 0; i < N_DESCR; ++i, ns += 4)
PUT_32BE(ns, descr[i]);
/* fill in the second program header entry and the RPA note area */
ph += ps;
PUT_32(ph + PH_TYPE, PT_NOTE);
if (e_class == ELFCLASS32)
PUT_32(ph + PH_OFFSET, ns);
else
PUT_64(ph + PH_OFFSET, ns);
if (e_class == ELFCLASS32)
PUT_32(ph + PH_FILESZ, nnote);
else
PUT_64(ph + PH_FILESZ, nnote2);
/* fill in the note area we point to */
PUT_32(ns, strlen(rpaname) + 1);
PUT_32(ns + 4, sizeof(rpanote));
PUT_32(ns + 8, 0x12759999);
strcpy((char *) &buf[ns + 12], rpaname);
ns += 12 + ROUNDUP(strlen(rpaname) + 1);
for (i = 0; i < N_RPA_DESCR; ++i, ns += 4)
PUT_32BE(ns, rpanote[i]);
/* Update the number of program headers */
PUT_16(E_PHNUM, np + 2);
/* write back */
lseek(fd, (long) 0, SEEK_SET);
i = write(fd, buf, n);
if (i < 0) {
perror("write");
exit(1);
}
if (i < n) {
fprintf(stderr, "%s: write truncated\n", av[1]);
exit(1);
}
exit(0);
notelf:
fprintf(stderr, "%s does not appear to be an ELF file\n", av[1]);
exit(1);
nospace:
fprintf(stderr, "sorry, I can't find space in %s to put the note\n",
av[1]);
exit(1);
}
