stream.c

sigmadesign smp8623 gui source code ,bingo

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/stat.h>

#include <fcntl.h>
#include <signal.h>
//#include <strings.h>

//#include "config.h"

//#define closesocket close
//ream_pri
//#include "mp_msg.h"
//#include "help_mp.h"
//#include "osdep/shmem.h"

#include "../include/stream.h"
//#include "libmpdemux/demuxer.h"

//#include "m_option.h"
//#include "m_struct.h"

//#include "cache2.h"

//#include "vcd_read_bincue.h"

extern stream_info_t stream_info_file;

stream_info_t* auto_open_streams[] = {
  &stream_info_file,
  NULL
};

static stream_t* open_stream_plugin(stream_info_t* sinfo,RMascii* filename,RMint32 mode,
			     RMascii** options, RMint32* file_format, RMint32* ret) {
  void* arg = filename;
  stream_t* s;
//  m_struct_t* desc = (m_struct_t*)sinfo->opts;

//  // Parse options
//  if(desc) {
//    arg = m_struct_alloc(desc);
//  }
	s = new_stream(-2,-2);
	s->url= STRDUP(filename); //strdup(filename);
	s->flags |= mode;
	*ret = sinfo->open(s,mode,arg,file_format);
	if((*ret) != STREAM_OK) {
    	RFREE(s->url);
    	RFREE(s);
    	return NULL;
  	}
  
  	if(s->flags & STREAM_SEEK && !s->seek)
    	s->flags &= ~STREAM_SEEK;
  	if(s->seek && !(s->flags & STREAM_SEEK))
    	s->flags |= STREAM_SEEK;
  
  	return s;
}


stream_t* open_stream_full(RMascii* filename,RMint32 mode, RMascii** options, RMint32* file_format) {
	RMint32 i,j,l,r;
	stream_info_t* sinfo;
	stream_t* s;

	for(i = 0 ; auto_open_streams[i] ; i++) {
		sinfo = auto_open_streams[i];
		if(!sinfo->protocols) {
			continue;
		}
		for(j = 0 ; sinfo->protocols[j] ; j++) {
			l = strlen(sinfo->protocols[j]);
			// l == 0 => Don't do protocol matching (ie network and filenames)
			if((l == 0) || ((RMNCompareAscii(sinfo->protocols[j],filename,l) == 0) &&
				(RMNCompareAscii("://",filename+l,3) == 0))) {
				//	*file_format = DEMUXER_TYPE_UNKNOWN;
				s = open_stream_plugin(sinfo,filename,mode,options,file_format,&r);
				if(s) return s;
				if(r != STREAM_UNSUPORTED) {
					return NULL;
				}
				break;
			}
		}
	}

	return NULL;
}

//=================== STREAMER =========================

RMint32 stream_fill_buffer(stream_t *s){
  int len;
  if (/*s->fd == NULL ||*/ s->eof) { s->buf_pos = s->buf_len = 0; return 0; }
  switch(s->type){
  case STREAMTYPE_STREAM:
    len=read(s->fd,s->buffer,STREAM_BUFFER_SIZE);
    break; 
    
  default: 
    len= s->fill_buffer ? s->fill_buffer(s,s->buffer,STREAM_BUFFER_SIZE) : 0;
  }
  if(len<=0){ s->eof=1; s->buf_pos=s->buf_len=0; return 0; }
  s->buf_pos=0;
  s->buf_len=len;
  s->pos+=len;
//  printf("[%d]",len);fflush(stdout);
  return len;
}

RMint32 stream_seek_long(stream_t *s,off_t pos){
off_t newpos=0;

//  if( mp_msg_test(MSGT_STREAM,MSGL_DBG3) ) printf("seek_long to 0x%X\n",(unsigned int)pos);

  s->buf_pos=s->buf_len=0;

  switch(s->type){
  case STREAMTYPE_STREAM:
    newpos=pos&(~(STREAM_BUFFER_SIZE-1));break;
  default:
    // Round on sector size
    if(s->sector_size)
      newpos=(pos/s->sector_size)*s->sector_size;
    else { // Otherwise on the buffer size
      newpos=pos&(~(STREAM_BUFFER_SIZE-1));break;
    }
    break;
  }
  pos-=newpos;

if(newpos==0 || newpos!=s->pos){
  switch(s->type){
  case STREAMTYPE_STREAM:
    //s->pos=newpos; // real seek
    // Some streaming protocol allow to seek backward and forward
    // A function call that return -1 can tell that the protocol
    // doesn't support seeking.
#ifdef MPLAYER_NETWORK
    if(s->seek) { // new stream seek is much cleaner than streaming_ctrl one
      if(!s->seek(s,newpos)) {
      	mp_msg(MSGT_STREAM,MSGL_ERR, "Seek failed\n");
      	return 0;
      }
      break;
    }
	
    if( s->streaming_ctrl!=NULL && s->streaming_ctrl->streaming_seek ) {
      if( s->streaming_ctrl->streaming_seek( s->fd, pos, s->streaming_ctrl )<0 ) {
        mp_msg(MSGT_STREAM,MSGL_INFO,"Stream not seekable!\n");
        return 1;
      }
    } 
#else
    if(newpos<s->pos){
      return 1;
    }
    while(s->pos<newpos){
      if(stream_fill_buffer(s)<=0) break; // EOF
    }
#endif
    break;
  default:
    // This should at the beginning as soon as all streams are converted
    if(!s->seek)
      return 0;
    // Now seek
    if(!s->seek(s,newpos)) {
      return 0;
    }
  }
//   putchar('.');fflush(stdout);
//} else {
//   putchar('%');fflush(stdout);
}

while(stream_fill_buffer(s) > 0 && pos >= 0) {
  if(pos<=(off_t)s->buf_len){
    s->buf_pos=pos; // byte position in sector
    return 1;
  }
  pos -= s->buf_len;
}
  
//  if(pos==s->buf_len) printf("XXX Seek to last byte of file -> EOF\n");
  return 0;
}


void stream_reset(stream_t *s){
  if(s->eof){
    s->pos=0; //ftell(f);
//    s->buf_pos=s->buf_len=0;
    s->eof=0;
  }
  if(s->control) s->control(s,STREAM_CTRL_RESET,NULL);
  //stream_seek(s,0);
}

RMint32 stream_control(stream_t *s, RMint32 cmd, void *arg){
  if(!s->control) return STREAM_UNSUPORTED;
  return s->control(s, cmd, arg);
}

//stream_t* new_memory_stream(RMuint8* data,RMint32 len){
//  stream_t *s;
//
//  if(len < 0)
//    return NULL;
//  s=malloc(sizeof(stream_t)+len);
//  memset(s,0,sizeof(stream_t));
//  s->fd=-1;
//  s->type=STREAMTYPE_MEMORY;
//  s->buf_pos=0; s->buf_len=len;
//  s->start_pos=0; s->end_pos=len;
//  stream_reset(s);
//  s->pos=len;
//  memcpy(s->buffer,data,len);
//  return s;
//}

stream_t* new_stream(RMint32 fd,RMint32 type){
  stream_t *s= (stream_t *) MALLOC(sizeof(stream_t));
  if(s==NULL) return NULL;
  RMMemset(s,0,sizeof(stream_t));
  
  s->fd=fd;
  s->type=type;
  s->buf_pos=s->buf_len=0;
  s->start_pos=s->end_pos=0;
  s->priv=NULL;
  s->url=NULL;
  stream_reset(s);
  return s;
}

void free_stream(stream_t *s){
//  printf("\n*** free_stream() called ***\n");
//	RMascii* end;

  if(s->close) s->close(s);
  if(s->fd>0){
    /* on unix we define closesocket to close
       on windows however we have to distinguish between
       network socket and file */
//    if(s->url && RMFindAsciiString(s->url,"://", &end))
 //     closesocket(s->fd);
    close(s->fd);
  }

  // Disabled atm, i don't like that. s->priv can be anything after all
  // streams should destroy their priv on close
  //if(s->priv) free(s->priv);
  if(s->url) RFREE(s->url);
  RFREE(s);
}