stream/pnm.c

   1 /*
   2  * Copyright (C) 2000-2002 the xine project
   3  *
   4  * This file is part of xine, a free video player.
   5  *
   6  * xine is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * xine is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  *
  20  * $Id$
  21  *
  22  * pnm protocol implementation
  23  * based upon code from joschka
  24  */
  25
  26 #include <unistd.h>
  27 #include <stdio.h>
  28 #include <assert.h>
  29 #include <string.h>
  30 #include <sys/stat.h>
  31 #include <fcntl.h>
  32 #include <errno.h>
  33 #include <stdlib.h>
  34 #include <sys/time.h>
  35 #include <inttypes.h>
  36
  37 #include <libavutil/intreadwrite.h>
  38
  39 #include "config.h"
  40 #if !HAVE_WINSOCK2_H
  41 #include <sys/socket.h>
  42 //#include <netinet/in.h>
  43 //#include <netdb.h>
  44 #else
  45 #include <winsock2.h>
  46 #endif
  47
  48 #include "stream.h"
  49 #include "libmpdemux/demuxer.h"
  50 #include "osdep/timer.h"
  51 #include "network.h"
  52 #include "pnm.h"
  53 #include "tcp.h"
  54 //#include "libreal/rmff.h"
  55
  56 extern int network_bandwidth;
  57
  58 #define FOURCC_TAG( ch0, ch1, ch2, ch3 ) \
  59         (((long)(unsigned char)(ch3)       ) | \
  60         ( (long)(unsigned char)(ch2) << 8  ) | \
  61         ( (long)(unsigned char)(ch1) << 16 ) | \
  62         ( (long)(unsigned char)(ch0) << 24 ) )
  63
  64
  65 #define RMF_TAG   FOURCC_TAG('.', 'R', 'M', 'F')
  66 #define PROP_TAG  FOURCC_TAG('P', 'R', 'O', 'P')
  67 #define MDPR_TAG  FOURCC_TAG('M', 'D', 'P', 'R')
  68 #define CONT_TAG  FOURCC_TAG('C', 'O', 'N', 'T')
  69 #define DATA_TAG  FOURCC_TAG('D', 'A', 'T', 'A')
  70 #define INDX_TAG  FOURCC_TAG('I', 'N', 'D', 'X')
  71 #define PNA_TAG   FOURCC_TAG('P', 'N', 'A',  0 )
  72
  73 /*
  74 #define LOG
  75 */
  76
  77 #define BUF_SIZE 4096
  78 #define HEADER_SIZE 4096
  79
  80 struct pnm_s {
  81
  82   int           s;
  83
  84 //  char         *host;
  85 //  int           port;
  86   char         *path;
  87 //  char         *url;
  88
  89   char          buffer[BUF_SIZE]; /* scratch buffer */
  90
  91   /* receive buffer */
  92   uint8_t       recv[BUF_SIZE];
  93   int           recv_size;
  94   int           recv_read;
  95
  96   uint8_t       header[HEADER_SIZE];
  97   int           header_len;
  98   int           header_read;
  99   unsigned int  seq_num[4];     /* two streams with two indices   */
 100   unsigned int  seq_current[2]; /* seqs of last stream chunk read */
 101   uint32_t      ts_current;     /* timestamp of current chunk     */
 102   uint32_t      ts_last[2];     /* timestamps of last chunks      */
 103   unsigned int  packet;         /* number of last recieved packet */
 104 };
 105
 106 /* sizes */
 107 #define PREAMBLE_SIZE 8
 108 #define CHECKSUM_SIZE 3
 109
 110
 111 /* header of rm files */
 112 static const unsigned char rm_header[]={
 113         0x2e, 0x52, 0x4d, 0x46, /* object_id      ".RMF" */
 114         0x00, 0x00, 0x00, 0x12, /* header_size    0x12   */
 115         0x00, 0x00,             /* object_version 0x00   */
 116         0x00, 0x00, 0x00, 0x00, /* file_version   0x00   */
 117         0x00, 0x00, 0x00, 0x06  /* num_headers    0x06   */
 118 };
 119
 120 /* data chunk header */
 121 static const unsigned char pnm_data_header[]={
 122         'D','A','T','A',
 123          0,0,0,0,       /* data chunk size  */
 124          0,0,           /* object version   */
 125          0,0,0,0,       /* num packets      */
 126          0,0,0,0};      /* next data header */
 127
 128 /* pnm request chunk ids */
 129
 130 #define PNA_CLIENT_CAPS      0x03
 131 #define PNA_CLIENT_CHALLANGE 0x04
 132 #define PNA_BANDWIDTH        0x05
 133 #define PNA_GUID             0x13
 134 #define PNA_TIMESTAMP        0x17
 135 #define PNA_TWENTYFOUR       0x18
 136
 137 #define PNA_CLIENT_STRING    0x63
 138 #define PNA_PATH_REQUEST     0x52
 139
 140 static const unsigned char pnm_challenge[] = "0990f6b4508b51e801bd6da011ad7b56";
 141 static const unsigned char pnm_timestamp[] = "[15/06/1999:22:22:49 00:00]";
 142 static const unsigned char pnm_guid[]      = "3eac2411-83d5-11d2-f3ea-d7c3a51aa8b0";
 143 static const unsigned char pnm_response[]  = "97715a899cbe41cee00dd434851535bf";
 144 static const unsigned char client_string[] = "WinNT_9.0_6.0.6.45_plus32_MP60_en-US_686l";
 145
 146 static const unsigned char pnm_header[] = {
 147         'P','N','A',
 148         0x00, 0x0a,
 149         0x00, 0x14,
 150         0x00, 0x02,
 151         0x00, 0x01 };
 152
 153 static const unsigned char pnm_client_caps[] = {
 154     0x07, 0x8a, 'p','n','r','v',
 155        0, 0x90, 'p','n','r','v',
 156        0, 0x64, 'd','n','e','t',
 157        0, 0x46, 'p','n','r','v',
 158        0, 0x32, 'd','n','e','t',
 159        0, 0x2b, 'p','n','r','v',
 160        0, 0x28, 'd','n','e','t',
 161        0, 0x24, 'p','n','r','v',
 162        0, 0x19, 'd','n','e','t',
 163        0, 0x18, 'p','n','r','v',
 164        0, 0x14, 's','i','p','r',
 165        0, 0x14, 'd','n','e','t',
 166        0, 0x24, '2','8','_','8',
 167        0, 0x12, 'p','n','r','v',
 168        0, 0x0f, 'd','n','e','t',
 169        0, 0x0a, 's','i','p','r',
 170        0, 0x0a, 'd','n','e','t',
 171        0, 0x08, 's','i','p','r',
 172        0, 0x06, 's','i','p','r',
 173        0, 0x12, 'l','p','c','J',
 174        0, 0x07, '0','5','_','6' };
 175
 176 static const uint32_t pnm_default_bandwidth=10485800;
 177 static const uint32_t pnm_available_bandwidths[]={14400,19200,28800,33600,34430,57600,
 178                                   115200,262200,393216,524300,1544000,10485800};
 179
 180 static const unsigned char pnm_twentyfour[]={
 181     0xd5, 0x42, 0xa3, 0x1b, 0xef, 0x1f, 0x70, 0x24,
 182     0x85, 0x29, 0xb3, 0x8d, 0xba, 0x11, 0xf3, 0xd6 };
 183
 184 /* now other data follows. marked with 0x0000 at the beginning */
 185 static const unsigned char after_chunks[]={
 186     0x00, 0x00, /* mark */
 187
 188     0x50, 0x84, /* seems to be fixated */
 189     0x1f, 0x3a  /* varies on each request (checksum ?)*/
 190     };
 191
 192 static void hexdump (char *buf, int length);
 193
 194 static int rm_write(int s, const char *buf, int len) {
 195   int total, timeout;
 196
 197   total = 0; timeout = 30;
 198   while (total < len){
 199     int n;
 200
 201     n = send (s, &buf[total], len - total, 0);
 202
 203     if (n > 0)
 204       total += n;
 205     else if (n < 0) {
 206 #if !HAVE_WINSOCK2_H
 207       if (timeout>0 && (errno == EAGAIN || errno == EINPROGRESS)) {
 208 #else
 209       if (timeout>0 && (errno == EAGAIN || WSAGetLastError() == WSAEINPROGRESS)) {
 210 #endif
 211         usec_sleep (1000000); timeout--;
 212       } else
 213         return -1;
 214     }
 215   }
 216
 217   return total;
 218 }
 219
 220 static ssize_t rm_read(int fd, void *buf, size_t count) {
 221
 222   ssize_t ret, total;
 223
 224   total = 0;
 225
 226   while (total < count) {
 227
 228     fd_set rset;
 229     struct timeval timeout;
 230
 231     FD_ZERO (&rset);
 232     FD_SET  (fd, &rset);
 233
 234     timeout.tv_sec  = 3;
 235     timeout.tv_usec = 0;
 236
 237     if (select (fd+1, &rset, NULL, NULL, &timeout) <= 0) {
 238       return -1;
 239     }
 240
 241     ret=recv (fd, ((uint8_t*)buf)+total, count-total, 0);
 242
 243     if (ret<=0) {
 244       mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: read error.\n");
 245       return ret;
 246     } else
 247       total += ret;
 248   }
 249
 250   return total;
 251 }
 252
 253 /*
 254  * debugging utilities
 255  */
 256
 257 static void hexdump (char *buf, int length) {
 258
 259   int i;
 260
 261   mp_msg(MSGT_OPEN, MSGL_INFO, "input_pnm: ascii>");
 262   for (i = 0; i < length; i++) {
 263     unsigned char c = buf[i];
 264
 265     if (c >= 32 && c <= 128)
 266       mp_msg(MSGT_OPEN, MSGL_INFO, "%c", c);
 267     else
 268       mp_msg(MSGT_OPEN, MSGL_INFO, ".");
 269   }
 270   mp_msg(MSGT_OPEN, MSGL_INFO, "\n");
 271
 272   mp_msg(MSGT_OPEN, MSGL_INFO, "input_pnm: hexdump> ");
 273   for (i = 0; i < length; i++) {
 274     unsigned char c = buf[i];
 275
 276     mp_msg(MSGT_OPEN, MSGL_INFO, "%02x", c);
 277
 278     if ((i % 16) == 15)
 279       mp_msg(MSGT_OPEN, MSGL_INFO, "\npnm:         ");
 280
 281     if ((i % 2) == 1)
 282       mp_msg(MSGT_OPEN, MSGL_INFO, " ");
 283
 284   }
 285   mp_msg(MSGT_OPEN, MSGL_INFO, "\n");
 286 }
 287
 288 /*
 289  * pnm_get_chunk gets a chunk from stream
 290  * and returns number of bytes read
 291  */
 292
 293 static int pnm_get_chunk(pnm_t *p,
 294                          unsigned int max,
 295                          unsigned int *chunk_type,
 296                          char *data, int *need_response) {
 297
 298   unsigned int chunk_size;
 299   unsigned int n;
 300   char *ptr;
 301
 302   if (max < PREAMBLE_SIZE)
 303     return -1;
 304
 305   /* get first PREAMBLE_SIZE bytes and ignore checksum */
 306   rm_read (p->s, data, CHECKSUM_SIZE);
 307   if (data[0] == 0x72)
 308     rm_read (p->s, data, PREAMBLE_SIZE);
 309   else
 310     rm_read (p->s, data+CHECKSUM_SIZE, PREAMBLE_SIZE-CHECKSUM_SIZE);
 311
 312   max -= PREAMBLE_SIZE;
 313
 314   *chunk_type = AV_RB32(data);
 315   chunk_size = AV_RB32(data+4);
 316
 317   switch (*chunk_type) {
 318     case PNA_TAG:
 319       *need_response=0;
 320       ptr=data+PREAMBLE_SIZE;
 321       if (max < 1)
 322         return -1;
 323       rm_read (p->s, ptr++, 1);
 324       max -= 1;
 325
 326       while(1) {
 327         /* expecting following chunk format: 0x4f <chunk size> <data...> */
 328
 329         if (max < 2)
 330           return -1;
 331         rm_read (p->s, ptr, 2);
 332         max -= 2;
 333         if (*ptr == 'X') /* checking for server message */
 334         {
 335           mp_msg(MSGT_OPEN, MSGL_WARN, "input_pnm: got a message from server:\n");
 336           if (max < 1)
 337             return -1;
 338           rm_read (p->s, ptr+2, 1);
 339           max = -1;
 340           n=AV_RB16(ptr+1);
 341           if (max < n)
 342             return -1;
 343           rm_read (p->s, ptr+3, n);
 344           max -= n;
 345           ptr[3+n]=0;
 346           mp_msg(MSGT_OPEN, MSGL_WARN, "%s\n",ptr+3);
 347           return -1;
 348         }
 349
 350         if (*ptr == 'F') /* checking for server error */
 351         {
 352           mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: server error.\n");
 353           return -1;
 354         }
 355         if (*ptr == 'i')
 356         {
 357           ptr+=2;
 358           *need_response=1;
 359           continue;
 360         }
 361         if (*ptr != 0x4f) break;
 362         n=ptr[1];
 363         if (max < n)
 364           return -1;
 365         rm_read (p->s, ptr+2, n);
 366         max -= n;
 367         ptr+=(n+2);
 368       }
 369       /* the checksum of the next chunk is ignored here */
 370       if (max < 1)
 371         return -1;
 372       rm_read (p->s, ptr+2, 1);
 373       ptr+=3;
 374       chunk_size=ptr-data;
 375       break;
 376     case RMF_TAG:
 377     case DATA_TAG:
 378     case PROP_TAG:
 379     case MDPR_TAG:
 380     case CONT_TAG:
 381       if (chunk_size > max || chunk_size < PREAMBLE_SIZE) {
 382         mp_msg(MSGT_OPEN, MSGL_ERR, "error: max chunk size exceeded (max was 0x%04x)\n", max);
 383 #ifdef LOG
 384         n=rm_read (p->s, &data[PREAMBLE_SIZE], 0x100 - PREAMBLE_SIZE);
 385         hexdump(data,n+PREAMBLE_SIZE);
 386 #endif
 387         return -1;
 388       }
 389       rm_read (p->s, &data[PREAMBLE_SIZE], chunk_size-PREAMBLE_SIZE);
 390       break;
 391     default:
 392       *chunk_type = 0;
 393       chunk_size  = PREAMBLE_SIZE;
 394       break;
 395   }
 396
 397   return chunk_size;
 398 }
 399
 400 /*
 401  * writes a chunk to a buffer, returns number of bytes written
 402  */
 403
 404 static int pnm_write_chunk(uint16_t chunk_id, uint16_t length,
 405     const char *chunk, char *data) {
 406
 407   AV_WB16(&data[0], chunk_id);
 408   AV_WB16(&data[2], length);
 409   memcpy(&data[4],chunk,length);
 410
 411   return length+4;
 412 }
 413
 414 /*
 415  * constructs a request and sends it
 416  */
 417
 418 static void pnm_send_request(pnm_t *p, uint32_t bandwidth) {
 419
 420   int c=sizeof(pnm_header);
 421   char fixme[]={0,1};
 422
 423   memcpy(p->buffer,pnm_header,sizeof(pnm_header));
 424   c+=pnm_write_chunk(PNA_CLIENT_CHALLANGE,strlen(pnm_challenge),
 425           pnm_challenge,&p->buffer[c]);
 426   c+=pnm_write_chunk(PNA_CLIENT_CAPS,sizeof(pnm_client_caps),
 427           pnm_client_caps,&p->buffer[c]);
 428   c+=pnm_write_chunk(0x0a,0,NULL,&p->buffer[c]);
 429   c+=pnm_write_chunk(0x0c,0,NULL,&p->buffer[c]);
 430   c+=pnm_write_chunk(0x0d,0,NULL,&p->buffer[c]);
 431   c+=pnm_write_chunk(0x16,2,fixme,&p->buffer[c]);
 432   c+=pnm_write_chunk(PNA_TIMESTAMP,strlen(pnm_timestamp),
 433           pnm_timestamp,&p->buffer[c]);
 434   c+=pnm_write_chunk(PNA_BANDWIDTH,4,
 435           (const char *)&pnm_default_bandwidth,&p->buffer[c]);
 436   c+=pnm_write_chunk(0x08,0,NULL,&p->buffer[c]);
 437   c+=pnm_write_chunk(0x0e,0,NULL,&p->buffer[c]);
 438   c+=pnm_write_chunk(0x0f,0,NULL,&p->buffer[c]);
 439   c+=pnm_write_chunk(0x11,0,NULL,&p->buffer[c]);
 440   c+=pnm_write_chunk(0x10,0,NULL,&p->buffer[c]);
 441   c+=pnm_write_chunk(0x15,0,NULL,&p->buffer[c]);
 442   c+=pnm_write_chunk(0x12,0,NULL,&p->buffer[c]);
 443   c+=pnm_write_chunk(PNA_GUID,strlen(pnm_guid),
 444           pnm_guid,&p->buffer[c]);
 445   c+=pnm_write_chunk(PNA_TWENTYFOUR,sizeof(pnm_twentyfour),
 446           pnm_twentyfour,&p->buffer[c]);
 447
 448   /* data after chunks */
 449   memcpy(&p->buffer[c],after_chunks,sizeof(after_chunks));
 450   c+=sizeof(after_chunks);
 451
 452   /* client id string */
 453   p->buffer[c]=PNA_CLIENT_STRING;
 454   AV_WB16(&p->buffer[c+1], strlen(client_string)-1); /* don't know why do we have -1 here */
 455   memcpy(&p->buffer[c+3],client_string,strlen(client_string)+1);
 456   c=c+3+strlen(client_string)+1;
 457
 458   /* file path */
 459   p->buffer[c]=0;
 460   p->buffer[c+1]=PNA_PATH_REQUEST;
 461   AV_WB16(&p->buffer[c+2], strlen(p->path));
 462   memcpy(&p->buffer[c+4],p->path,strlen(p->path));
 463   c=c+4+strlen(p->path);
 464
 465   /* some trailing bytes */
 466   p->buffer[c]='y';
 467   p->buffer[c+1]='B';
 468
 469   rm_write(p->s,p->buffer,c+2);
 470 }
 471
 472 /*
 473  * pnm_send_response sends a response of a challenge
 474  */
 475
 476 static void pnm_send_response(pnm_t *p, const char *response) {
 477
 478   int size=strlen(response);
 479
 480   p->buffer[0]=0x23;
 481   p->buffer[1]=0;
 482   p->buffer[2]=(unsigned char) size;
 483
 484   memcpy(&p->buffer[3], response, size);
 485
 486   rm_write (p->s, p->buffer, size+3);
 487
 488 }
 489
 490 /*
 491  * get headers and challenge and fix headers
 492  * write headers to p->header
 493  * write challenge to p->buffer
 494  *
 495  * return 0 on error.  != 0 on success
 496  */
 497
 498 static int pnm_get_headers(pnm_t *p, int *need_response) {
 499
 500   uint32_t chunk_type;
 501   uint8_t  *ptr=p->header;
 502   uint8_t  *prop_hdr=NULL;
 503   int      chunk_size,size=0;
 504   int      nr = 0;
 505 /*  rmff_header_t *h; */
 506
 507   *need_response=0;
 508
 509   while(1) {
 510     if (HEADER_SIZE-size<=0)
 511     {
 512       mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: header buffer overflow. exiting\n");
 513       return 0;
 514     }
 515     chunk_size=pnm_get_chunk(p,HEADER_SIZE-size,&chunk_type,ptr,&nr);
 516     if (chunk_size < 0) return 0;
 517     if (chunk_type == 0) break;
 518     if (chunk_type == PNA_TAG)
 519     {
 520       memcpy(ptr, rm_header, sizeof(rm_header));
 521       chunk_size=sizeof(rm_header);
 522       *need_response=nr;
 523     }
 524     if (chunk_type == DATA_TAG)
 525       chunk_size=0;
 526     if (chunk_type == RMF_TAG)
 527       chunk_size=0;
 528     if (chunk_type == PROP_TAG)
 529         prop_hdr=ptr;
 530     size+=chunk_size;
 531     ptr+=chunk_size;
 532   }
 533
 534   if (!prop_hdr) {
 535     mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: error while parsing headers.\n");
 536     return 0;
 537   }
 538
 539   /* set data offset */
 540   AV_WB32(&prop_hdr[42], size - 1);
 541
 542   /* read challenge */
 543   memcpy (p->buffer, ptr, PREAMBLE_SIZE);
 544   rm_read (p->s, &p->buffer[PREAMBLE_SIZE], 64);
 545
 546   /* now write a data header */
 547   memcpy(ptr, pnm_data_header, sizeof(pnm_data_header));
 548   size+=sizeof(pnm_data_header);
 549 /*
 550   h=rmff_scan_header(p->header);
 551   rmff_fix_header(h);
 552   p->header_len=rmff_get_header_size(h);
 553   rmff_dump_header(h, p->header, HEADER_SIZE);
 554 */
 555   p->header_len=size;
 556
 557   return 1;
 558 }
 559
 560 /*
 561  * determine correct stream number by looking at indices
 562  */
 563
 564 static int pnm_calc_stream(pnm_t *p) {
 565
 566   char str0=0,str1=0;
 567
 568   /* looking at the first index to
 569    * find possible stream types
 570    */
 571   if (p->seq_current[0]==p->seq_num[0]) str0=1;
 572   if (p->seq_current[0]==p->seq_num[2]) str1=1;
 573
 574   switch (str0+str1) {
 575     case 1: /* one is possible, good. */
 576       if (str0)
 577       {
 578         p->seq_num[0]++;
 579         p->seq_num[1]=p->seq_current[1]+1;
 580         return 0;
 581       } else
 582       {
 583         p->seq_num[2]++;
 584         p->seq_num[3]=p->seq_current[1]+1;
 585         return 1;
 586       }
 587       break;
 588     case 0:
 589     case 2: /* both types or none possible, not so good */
 590       /* try to figure out by second index */
 591       if (   p->seq_current[1] == p->seq_num[1]
 592           && p->seq_current[1] != p->seq_num[3])
 593       {
 594         /* ok, only stream0 matches */
 595         p->seq_num[0]=p->seq_current[0]+1;
 596         p->seq_num[1]++;
 597         return 0;
 598       }
 599       if (   p->seq_current[1] == p->seq_num[3]
 600           && p->seq_current[1] != p->seq_num[1])
 601       {
 602         /* ok, only stream1 matches */
 603         p->seq_num[2]=p->seq_current[0]+1;
 604         p->seq_num[3]++;
 605         return 1;
 606       }
 607       /* wow, both streams match, or not.   */
 608       /* now we try to decide by timestamps */
 609       if (p->ts_current < p->ts_last[1])
 610         return 0;
 611       if (p->ts_current < p->ts_last[0])
 612         return 1;
 613       /* does not help, we guess type 0     */
 614 #ifdef LOG
 615       mp_msg(MSGT_OPEN, MSGL_INFO, "guessing stream# 0\n");
 616 #endif
 617       p->seq_num[0]=p->seq_current[0]+1;
 618       p->seq_num[1]=p->seq_current[1]+1;
 619       return 0;
 620       break;
 621   }
 622   mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: wow, something very nasty happened in pnm_calc_stream\n");
 623   return 2;
 624 }
 625
 626 /*
 627  * gets a stream chunk and writes it to a recieve buffer
 628  */
 629
 630 static int pnm_get_stream_chunk(pnm_t *p) {
 631
 632   int  n;
 633   char keepalive='!';
 634   unsigned int fof1, fof2, stream;
 635
 636   /* send a keepalive                               */
 637   /* realplayer seems to do that every 43th package */
 638   if (p->packet%43 == 42)
 639     rm_write(p->s,&keepalive,1);
 640
 641   /* data chunks begin with: 'Z' <o> <o> <i1> 'Z' <i2>
 642    * where <o> is the offset to next stream chunk,
 643    * <i1> is a 16 bit index
 644    * <i2> is a 8 bit index which counts from 0x10 to somewhere
 645    */
 646
 647   n = rm_read (p->s, p->buffer, 8);
 648   if (n<0) return -1;
 649   if (n<8) return 0;
 650
 651   /* skip 8 bytes if 0x62 is read */
 652   if (p->buffer[0] == 0x62)
 653   {
 654     n = rm_read (p->s, p->buffer, 8);
 655     if (n<8) return 0;
 656 #ifdef LOG
 657     mp_msg(MSGT_OPEN, MSGL_WARN, "input_pnm: had to seek 8 bytes on 0x62\n");
 658 #endif
 659   }
 660
 661   /* a server message */
 662   if (p->buffer[0] == 'X')
 663   {
 664     int size=AV_RB16(&p->buffer[1]);
 665
 666     rm_read (p->s, &p->buffer[8], size-5);
 667     p->buffer[size+3]=0;
 668     mp_msg(MSGT_OPEN, MSGL_WARN, "input_pnm: got message from server while reading stream:\n%s\n", &p->buffer[3]);
 669     return -1;
 670   }
 671   if (p->buffer[0] == 'F')
 672   {
 673     mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: server error.\n");
 674     return -1;
 675   }
 676
 677   /* skip bytewise to next chunk.
 678    * seems, that we don't need that, if we send enough
 679    * keepalives
 680    */
 681   n=0;
 682   while (p->buffer[0] != 0x5a) {
 683     int i;
 684     for (i=1; i<8; i++)
 685       p->buffer[i-1]=p->buffer[i];
 686     rm_read (p->s, &p->buffer[7], 1);
 687     n++;
 688   }
 689
 690 #ifdef LOG
 691   if (n) mp_msg(MSGT_OPEN, MSGL_WARN, "input_pnm: had to seek %i bytes to next chunk\n", n);
 692 #endif
 693
 694   /* check for 'Z's */
 695   if (p->buffer[0] != 0x5a || p->buffer[7] != 0x5a)
 696   {
 697     mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: bad boundaries\n");
 698     hexdump(p->buffer, 8);
 699     return 0;
 700   }
 701
 702   /* check offsets */
 703   fof1=AV_RB16(&p->buffer[1]);
 704   fof2=AV_RB16(&p->buffer[3]);
 705   if (fof1 != fof2)
 706   {
 707     mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: frame offsets are different: 0x%04x 0x%04x\n",fof1,fof2);
 708     return 0;
 709   }
 710
 711   /* get first index */
 712   p->seq_current[0]=AV_RB16(&p->buffer[5]);
 713
 714   /* now read the rest of stream chunk */
 715   n = rm_read (p->s, &p->recv[5], fof1-5);
 716   if (n<fof1-5) return 0;
 717
 718   /* get second index */
 719   p->seq_current[1]=p->recv[5];
 720
 721   /* get timestamp */
 722   p->ts_current=AV_RB32(&p->recv[6]);
 723
 724   /* get stream number */
 725   stream=pnm_calc_stream(p);
 726
 727   /* saving timestamp */
 728   p->ts_last[stream]=p->ts_current;
 729
 730   /* constructing a data packet header */
 731
 732   p->recv[0]=0;        /* object version */
 733   p->recv[1]=0;
 734
 735   AV_WB16(&p->recv[2], fof2); /* length */
 736
 737   p->recv[4]=0;         /* stream number */
 738   p->recv[5]=stream;
 739
 740   p->recv[10] &= 0xfe; /* streambox seems to do that... */
 741
 742   p->packet++;
 743
 744   p->recv_size=fof1;
 745
 746   return fof1;
 747 }
 748
 749 // pnm_t *pnm_connect(const char *mrl) {
 750 static pnm_t *pnm_connect(int fd, char *path) {
 751
 752   pnm_t *p=malloc(sizeof(pnm_t));
 753   int need_response=0;
 754
 755   p->path=strdup(path);
 756   p->s=fd;
 757
 758   pnm_send_request(p,pnm_available_bandwidths[10]);
 759   if (!pnm_get_headers(p, &need_response)) {
 760     mp_msg(MSGT_OPEN, MSGL_ERR, "input_pnm: failed to set up stream\n");
 761     free(p->path);
 762     free(p);
 763     return NULL;
 764   }
 765   if (need_response)
 766     pnm_send_response(p, pnm_response);
 767   p->ts_last[0]=0;
 768   p->ts_last[1]=0;
 769
 770   /* copy header to recv */
 771
 772   memcpy(p->recv, p->header, p->header_len);
 773   p->recv_size = p->header_len;
 774   p->recv_read = 0;
 775
 776   return p;
 777 }
 778
 779 static int pnm_read (pnm_t *this, char *data, int len) {
 780
 781   int to_copy=len;
 782   char *dest=data;
 783   char *source=this->recv + this->recv_read;
 784   int fill=this->recv_size - this->recv_read;
 785   int retval;
 786
 787   if (len < 0) return 0;
 788   while (to_copy > fill) {
 789
 790     memcpy(dest, source, fill);
 791     to_copy -= fill;
 792     dest += fill;
 793     this->recv_read=0;
 794
 795     if ((retval = pnm_get_stream_chunk (this)) <= 0) {
 796 #ifdef LOG
 797       mp_msg(MSGT_OPEN, MSGL_INFO, "input_pnm: %d of %d bytes provided\n", len-to_copy, len);
 798 #endif
 799       if (retval < 0)
 800         return retval;
 801       else
 802       return len-to_copy;
 803     }
 804     source = this->recv;
 805     fill = this->recv_size - this->recv_read;
 806   }
 807
 808   memcpy(dest, source, to_copy);
 809   this->recv_read += to_copy;
 810
 811 #ifdef LOG
 812   mp_msg(MSGT_OPEN, MSGL_INFO, "input_pnm: %d bytes provided\n", len);
 813 #endif
 814
 815   return len;
 816 }
 817
 818 static int pnm_streaming_read( int fd, char *buffer, int size, streaming_ctrl_t *stream_ctrl ) {
 819         return pnm_read(stream_ctrl->data, buffer, size);
 820 }
 821
 822 static int open_s(stream_t *stream,int mode, void* opts, int* file_format) {
 823   int fd;
 824   pnm_t *pnm;
 825   URL_t *url;
 826
 827   mp_msg(MSGT_OPEN, MSGL_INFO, "STREAM_PNM, URL: %s\n", stream->url);
 828   stream->streaming_ctrl = streaming_ctrl_new();
 829   if(stream->streaming_ctrl==NULL)
 830     return STREAM_ERROR;
 831
 832   stream->streaming_ctrl->bandwidth = network_bandwidth;
 833   url = url_new(stream->url);
 834   stream->streaming_ctrl->url = check4proxies(url);
 835   //url_free(url);
 836
 837   fd = connect2Server( stream->streaming_ctrl->url->hostname,
 838     stream->streaming_ctrl->url->port ? stream->streaming_ctrl->url->port : 7070,1 );
 839
 840   if(fd<0)
 841     goto fail;
 842
 843   pnm = pnm_connect(fd,stream->streaming_ctrl->url->file);
 844   if(!pnm)
 845     goto fail;
 846   stream->type = STREAMTYPE_STREAM;
 847   stream->fd=fd;
 848   stream->streaming_ctrl->data=pnm;
 849   stream->streaming_ctrl->streaming_read = pnm_streaming_read;
 850   //stream->streaming_ctrl->streaming_seek = nop_streaming_seek;
 851   stream->streaming_ctrl->prebuffer_size = 8*1024;  // 8 KBytes
 852   stream->streaming_ctrl->buffering = 1;
 853   stream->streaming_ctrl->status = streaming_playing_e;
 854   *file_format = DEMUXER_TYPE_REAL;
 855   fixup_network_stream_cache(stream);
 856   return STREAM_OK;
 857
 858 fail:
 859   streaming_ctrl_free(stream->streaming_ctrl);
 860   stream->streaming_ctrl = NULL;
 861   return STREAM_UNSUPPORTED;
 862 }
 863
 864
 865 const stream_info_t stream_info_pnm = {
 866   "RealNetworks pnm",
 867   "pnm",
 868   "Arpi, xine team",
 869   "ported from xine",
 870   open_s,
 871   {"pnm", NULL},        //pnm as fallback
 872   NULL,
 873   0 // Urls are an option string
 874 };