RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity

stream: uncrustify stream.c/.h 

The formatting almost made me break out in tears.
This commit is contained in:
wm4 2013-01-24 17:43:07 +01:00
parent 42b47624f8
commit 47cec75291
2 changed files with 655 additions and 573 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

384
stream/stream.c
View File

@ -54,10 +54,10 @@
#include "cache2.h"
/// We keep these 2 for the gui atm, but they will be removed.
int vcd_track=0;
char* cdrom_device=NULL;
char* dvd_device=NULL;
int dvd_title=0;
int vcd_track = 0;
char *cdrom_device = NULL;
char *dvd_device = NULL;
int dvd_title = 0;
struct input_ctx;
static int (*stream_check_interrupt_cb)(struct input_ctx *ctx, int time);
@ -86,7 +86,7 @@ extern const stream_info_t stream_info_ifo;
extern const stream_info_t stream_info_dvd;
extern const stream_info_t stream_info_bluray;
static const stream_info_t* const auto_open_streams[] = {
static const stream_info_t *const auto_open_streams[] = {
#ifdef CONFIG_VCD
&stream_info_vcd,
#endif
@ -142,30 +142,33 @@ static stream_t *open_stream_plugin(const stream_info_t *sinfo,
int *file_format, int *ret,
char **redirected_url)
{
void* arg = NULL;
stream_t* s;
m_struct_t* desc = (m_struct_t*)sinfo->opts;
void *arg = NULL;
stream_t *s;
m_struct_t *desc = (m_struct_t *)sinfo->opts;
// Parse options
if(desc) {
if (desc) {
arg = m_struct_alloc(desc);
if(sinfo->opts_url) {
m_option_t url_opt =
{ "stream url", arg , CONF_TYPE_CUSTOM_URL, 0, 0 ,0, (void *)sinfo->opts };
if (m_option_parse(&url_opt, bstr0("stream url"), bstr0(filename), arg) < 0) {
mp_tmsg(MSGT_OPEN,MSGL_ERR, "URL parsing failed on url %s\n",filename);
m_struct_free(desc,arg);
if (sinfo->opts_url) {
m_option_t url_opt = { "stream url", arg, CONF_TYPE_CUSTOM_URL, 0,
0, 0, (void *)sinfo->opts };
if (m_option_parse(&url_opt, bstr0("stream url"), bstr0(filename),
arg) < 0)
{
mp_tmsg(MSGT_OPEN, MSGL_ERR, "URL parsing failed on url %s\n",
filename);
m_struct_free(desc, arg);
*ret = STREAM_ERROR;
return NULL;
}
}
}
s = new_stream(-2,-2);
s = new_stream(-2, -2);
s->opts = options;
s->url=strdup(filename);
s->url = strdup(filename);
s->flags |= mode;
*ret = sinfo->open(s,mode,arg,file_format);
if((*ret) != STREAM_OK) {
*ret = sinfo->open(s, mode, arg, file_format);
if ((*ret) != STREAM_OK) {
#ifdef CONFIG_NETWORKING
if (*ret == STREAM_REDIRECTED && redirected_url) {
if (s->streaming_ctrl && s->streaming_ctrl->url
@ -186,19 +189,19 @@ static stream_t *open_stream_plugin(const stream_info_t *sinfo,
s->cache_size = 320;
}
if(s->type <= -2)
mp_msg(MSGT_OPEN,MSGL_WARN, "Warning streams need a type !!!!\n");
if(s->flags & MP_STREAM_SEEK && !s->seek)
if (s->type <= -2)
mp_msg(MSGT_OPEN, MSGL_WARN, "Warning streams need a type !!!!\n");
if (s->flags & MP_STREAM_SEEK && !s->seek)
s->flags &= ~MP_STREAM_SEEK;
if(s->seek && !(s->flags & MP_STREAM_SEEK))
if (s->seek && !(s->flags & MP_STREAM_SEEK))
s->flags |= MP_STREAM_SEEK;
s->mode = mode;
mp_msg(MSGT_OPEN,MSGL_V, "STREAM: [%s] %s\n",sinfo->name,filename);
mp_msg(MSGT_OPEN,MSGL_V, "STREAM: Description: %s\n",sinfo->info);
mp_msg(MSGT_OPEN,MSGL_V, "STREAM: Author: %s\n", sinfo->author);
mp_msg(MSGT_OPEN,MSGL_V, "STREAM: Comment: %s\n", sinfo->comment);
mp_msg(MSGT_OPEN, MSGL_V, "STREAM: [%s] %s\n", sinfo->name, filename);
mp_msg(MSGT_OPEN, MSGL_V, "STREAM: Description: %s\n", sinfo->info);
mp_msg(MSGT_OPEN, MSGL_V, "STREAM: Author: %s\n", sinfo->author);
mp_msg(MSGT_OPEN, MSGL_V, "STREAM: Comment: %s\n", sinfo->comment);
if (s->mime_type)
mp_msg(MSGT_OPEN, MSGL_V, "Mime-type: '%s'\n", s->mime_type);
@ -210,9 +213,9 @@ static stream_t *open_stream_plugin(const stream_info_t *sinfo,
static stream_t *open_stream_full(const char *filename, int mode,
struct MPOpts *options, int *file_format)
{
int i,j,l,r;
const stream_info_t* sinfo;
stream_t* s;
int i, j, l, r;
const stream_info_t *sinfo;
stream_t *s;
char *redirected_url = NULL;
assert(filename);
@ -223,31 +226,38 @@ static stream_t *open_stream_full(const char *filename, int mode,
*file_format = DEMUXER_TYPE_UNKNOWN;
for(i = 0 ; auto_open_streams[i] ; i++) {
for (i = 0; auto_open_streams[i]; i++) {
sinfo = auto_open_streams[i];
if(!sinfo->protocols) {
mp_msg(MSGT_OPEN,MSGL_WARN, "Stream type %s has protocols == NULL, it's a bug\n", sinfo->name);
if (!sinfo->protocols) {
mp_msg(MSGT_OPEN, MSGL_WARN,
"Stream type %s has protocols == NULL, it's a bug\n",
sinfo->name);
continue;
}
for(j = 0 ; sinfo->protocols[j] ; j++) {
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 && !strstr(filename, "://")) ||
((strncasecmp(sinfo->protocols[j],filename,l) == 0) &&
(strncmp("://",filename+l,3) == 0))) {
if ((l == 0 && !strstr(filename, "://")) ||
((strncasecmp(sinfo->protocols[j], filename, l) == 0) &&
(strncmp("://", filename + l, 3) == 0))) {
*file_format = DEMUXER_TYPE_UNKNOWN;
s = open_stream_plugin(sinfo,filename,mode,options,file_format,&r,
s =
open_stream_plugin(sinfo, filename, mode, options,
file_format,
&r,
&redirected_url);
if(s) return s;
if(r == STREAM_REDIRECTED && redirected_url) {
mp_msg(MSGT_OPEN,MSGL_V, "[%s] open %s redirected to %s\n",
if (s)
return s;
if (r == STREAM_REDIRECTED && redirected_url) {
mp_msg(MSGT_OPEN, MSGL_V, "[%s] open %s redirected to %s\n",
sinfo->info, filename, redirected_url);
s = open_stream_full(redirected_url, mode, options, file_format);
s = open_stream_full(redirected_url, mode, options,
file_format);
free(redirected_url);
return s;
}
else if(r != STREAM_UNSUPPORTED) {
mp_tmsg(MSGT_OPEN,MSGL_ERR, "Failed to open %s.\n",filename);
} else if (r != STREAM_UNSUPPORTED) {
mp_tmsg(MSGT_OPEN, MSGL_ERR, "Failed to open %s.\n",
filename);
return NULL;
}
break;
@ -255,19 +265,19 @@ static stream_t *open_stream_full(const char *filename, int mode,
}
}
mp_tmsg(MSGT_OPEN,MSGL_ERR, "No stream found to handle url %s\n", filename);
mp_tmsg(MSGT_OPEN, MSGL_ERR, "No stream found to handle url %s\n", filename);
return NULL;
}
stream_t* open_stream(const char *filename, struct MPOpts *options,
stream_t *open_stream(const char *filename, struct MPOpts *options,
int *file_format)
{
return open_stream_full(filename,STREAM_READ,options,file_format);
return open_stream_full(filename, STREAM_READ, options, file_format);
}
stream_t *open_output_stream(const char *filename, struct MPOpts *options)
{
return open_stream_full(filename,STREAM_WRITE,options,NULL);
return open_stream_full(filename, STREAM_WRITE, options, NULL);
}
//=================== STREAMER =========================
@ -284,9 +294,10 @@ static int stream_reconnect(stream_t *s)
do {
if (retry >= MAX_RECONNECT_RETRIES)
return 0;
if (retry) usec_sleep(RECONNECT_SLEEP_MS * 1000);
if (retry)
usec_sleep(RECONNECT_SLEEP_MS * 1000);
retry++;
s->eof=1;
s->eof = 1;
stream_reset(s);
} while (stream_seek_internal(s, pos) >= 0 || s->pos != pos); // seek failed
return 1;
@ -296,30 +307,30 @@ int stream_read_internal(stream_t *s, void *buf, int len)
{
int orig_len = len;
// we will retry even if we already reached EOF previously.
switch(s->type){
switch (s->type) {
case STREAMTYPE_STREAM:
#ifdef CONFIG_NETWORKING
if( s->streaming_ctrl!=NULL && s->streaming_ctrl->streaming_read ) {
len=s->streaming_ctrl->streaming_read(s->fd, buf, len, s->streaming_ctrl);
if (s->streaming_ctrl != NULL && s->streaming_ctrl->streaming_read) {
len = s->streaming_ctrl->streaming_read(s->fd, buf, len,
s->streaming_ctrl);
if (s->streaming_ctrl->status == streaming_stopped_e &&
(!s->end_pos || s->pos == s->end_pos))
s->eof = 1;
} else
#endif
} else {
if (s->fill_buffer)
len = s->fill_buffer(s, buf, len);
else
len = read(s->fd, buf, len);
}
break;
case STREAMTYPE_DS:
len = demux_read_data((demux_stream_t*)s->priv, buf, len);
len = demux_read_data((demux_stream_t *)s->priv, buf, len);
break;
default:
len= s->fill_buffer ? s->fill_buffer(s, buf, len) : 0;
len = s->fill_buffer ? s->fill_buffer(s, buf, len) : 0;
}
if(len<=0){
if (len <= 0) {
// do not retry if this looks like proper eof
if (s->eof || (s->end_pos && s->pos == s->end_pos))
goto eof_out;
@ -329,36 +340,38 @@ int stream_read_internal(stream_t *s, void *buf, int len)
if (!stream_reconnect(s))
goto eof_out;
// make sure EOF is set to ensure no endless loops
s->eof=1;
s->eof = 1;
return stream_read_internal(s, buf, orig_len);
eof_out:
s->eof=1;
s->eof = 1;
return 0;
}
// When reading succeeded we are obviously not at eof.
// This e.g. avoids issues with eof getting stuck when lavf seeks in MPEG-TS
s->eof=0;
s->pos+=len;
s->eof = 0;
s->pos += len;
return len;
}
int stream_fill_buffer(stream_t *s){
int stream_fill_buffer(stream_t *s)
{
int len = stream_read_internal(s, s->buffer, STREAM_BUFFER_SIZE);
if (len <= 0)
return 0;
s->buf_pos=0;
s->buf_len=len;
s->buf_pos = 0;
s->buf_len = len;
// printf("[%d]",len);fflush(stdout);
return len;
}
int stream_write_buffer(stream_t *s, unsigned char *buf, int len) {
int stream_write_buffer(stream_t *s, unsigned char *buf, int len)
{
int rd;
if(!s->write_buffer)
if (!s->write_buffer)
return -1;
rd = s->write_buffer(s, buf, len);
if(rd < 0)
if (rd < 0)
return -1;
s->pos += rd;
assert(rd == len && "stream_write_buffer(): unexpected short write");
@ -367,31 +380,33 @@ int stream_write_buffer(stream_t *s, unsigned char *buf, int len) {
int stream_seek_internal(stream_t *s, int64_t newpos)
{
if(newpos==0 || newpos!=s->pos){
switch(s->type){
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 CONFIG_NETWORKING
if(s->seek) { // new stream seek is much cleaner than streaming_ctrl one
if(!s->seek(s,newpos)) {
mp_tmsg(MSGT_STREAM,MSGL_ERR, "Seek failed\n");
if (s->seek) { // new stream seek is much cleaner than streaming_ctrl one
if (!s->seek(s, newpos)) {
mp_tmsg(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, newpos, s->streaming_ctrl )<0 ) {
mp_tmsg(MSGT_STREAM,MSGL_INFO,"Stream not seekable!\n");
if (s->streaming_ctrl != NULL &&
s->streaming_ctrl->streaming_seek) {
if (s->streaming_ctrl->streaming_seek(s->fd, newpos,
s->streaming_ctrl) < 0) {
mp_tmsg(MSGT_STREAM, MSGL_INFO, "Stream not seekable!\n");
return 1;
}
break;
}
#endif
if(newpos<s->pos){
if (newpos < s->pos) {
mp_tmsg(MSGT_STREAM, MSGL_INFO,
"Cannot seek backward in linear streams!\n");
return 1;
@ -399,89 +414,98 @@ if(newpos==0 || newpos!=s->pos){
break;
default:
// This should at the beginning as soon as all streams are converted
if(!s->seek)
if (!s->seek)
return 0;
// Now seek
if(!s->seek(s,newpos)) {
mp_tmsg(MSGT_STREAM,MSGL_ERR, "Seek failed\n");
if (!s->seek(s, newpos)) {
mp_tmsg(MSGT_STREAM, MSGL_ERR, "Seek failed\n");
return 0;
}
}
// putchar('.');fflush(stdout);
//} else {
// putchar('%');fflush(stdout);
}
}
return -1;
}
int stream_seek_long(stream_t *s,int64_t pos){
int stream_seek_long(stream_t *s, int64_t pos)
{
int res;
int64_t newpos=0;
int64_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;
s->buf_pos = s->buf_len = 0;
if(s->mode == STREAM_WRITE) {
if(!s->seek || !s->seek(s,pos))
if (s->mode == STREAM_WRITE) {
if (!s->seek || !s->seek(s, pos))
return 0;
return 1;
}
if(s->sector_size)
newpos = (pos/s->sector_size)*s->sector_size;
if (s->sector_size)
newpos = (pos / s->sector_size) * s->sector_size;
else
newpos = pos&(~((int64_t)STREAM_BUFFER_SIZE-1));
newpos = pos & (~((int64_t)STREAM_BUFFER_SIZE - 1));
if( mp_msg_test(MSGT_STREAM,MSGL_DBG3) ){
mp_msg(MSGT_STREAM,MSGL_DBG3, "s->pos=%"PRIX64" newpos=%"PRIX64" new_bufpos=%"PRIX64" buflen=%X \n",
(int64_t)s->pos,(int64_t)newpos,(int64_t)pos,s->buf_len);
}
pos-=newpos;
if (mp_msg_test(MSGT_STREAM, MSGL_DBG3)) {
mp_msg(
MSGT_STREAM, MSGL_DBG3,
"s->pos=%" PRIX64 " newpos=%" PRIX64 " new_bufpos=%" PRIX64
" buflen=%X \n",
(int64_t)s->pos, (int64_t)newpos, (int64_t)pos, s->buf_len);
}
pos -= newpos;
res = stream_seek_internal(s, newpos);
if (res >= 0)
return res;
while(s->pos<newpos){
if(stream_fill_buffer(s)<=0) break; // EOF
while (s->pos < newpos) {
if (stream_fill_buffer(s) <= 0)
break; // EOF
}
s->eof = 0; // EOF reset when seek succeeds.
while (stream_fill_buffer(s) > 0) {
if(pos<=s->buf_len){
s->buf_pos=pos; // byte position in sector
s->eof = 0; // EOF reset when seek succeeds.
while (stream_fill_buffer(s) > 0) {
if (pos <= s->buf_len) {
s->buf_pos = pos; // byte position in sector
return 1;
}
pos -= s->buf_len;
}
// Fill failed, but seek still is a success.
s->pos += pos;
s->buf_pos = 0;
s->buf_len = 0;
mp_msg(MSGT_STREAM,MSGL_V,
"stream_seek: Seek to/past EOF: no buffer preloaded.\n");
return 1;
}
void stream_reset(stream_t *s){
if(s->eof){
s->pos=0;
s->buf_pos=s->buf_len=0;
s->eof=0;
}
if(s->control) s->control(s,STREAM_CTRL_RESET,NULL);
// Fill failed, but seek still is a success.
s->pos += pos;
s->buf_pos = 0;
s->buf_len = 0;
mp_msg(MSGT_STREAM, MSGL_V,
"stream_seek: Seek to/past EOF: no buffer preloaded.\n");
return 1;
}
void stream_reset(stream_t *s)
{
if (s->eof) {
s->pos = 0;
s->buf_pos = s->buf_len = 0;
s->eof = 0;
}
if (s->control)
s->control(s, STREAM_CTRL_RESET, NULL);
//stream_seek(s,0);
}
int stream_control(stream_t *s, int cmd, void *arg){
int stream_control(stream_t *s, int cmd, void *arg)
{
#ifdef CONFIG_STREAM_CACHE
if (s->cache_pid)
return cache_do_control(s, cmd, arg);
#endif
if(!s->control) return STREAM_UNSUPPORTED;
if (!s->control)
return STREAM_UNSUPPORTED;
return s->control(s, cmd, arg);
}
@ -494,64 +518,72 @@ void stream_update_size(stream_t *s)
}
}
stream_t* new_memory_stream(unsigned char* data,int len){
stream_t *new_memory_stream(unsigned char *data, int len)
{
stream_t *s;
if(len < 0)
if (len < 0)
return NULL;
s=calloc(1, sizeof(stream_t)+len);
s->fd=-1;
s->type=STREAMTYPE_MEMORY;
s->buf_pos=0; s->buf_len=len;
s->start_pos=0; s->end_pos=len;
s = calloc(1, sizeof(stream_t) + len);
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);
s->pos = len;
memcpy(s->buffer, data, len);
return s;
}
stream_t* new_stream(int fd,int type){
stream_t *s=talloc_zero(NULL, stream_t);
stream_t *new_stream(int fd, int type)
{
stream_t *s = talloc_zero(NULL, stream_t);
#if HAVE_WINSOCK2_H
{
WSADATA wsdata;
int temp = WSAStartup(0x0202, &wsdata); // there might be a better place for this (-> later)
mp_msg(MSGT_STREAM,MSGL_V,"WINSOCK2 init: %i\n", temp);
mp_msg(MSGT_STREAM, MSGL_V, "WINSOCK2 init: %i\n", temp);
}
#endif
s->fd=fd;
s->type=type;
s->fd = fd;
s->type = type;
stream_reset(s);
return s;
}
void free_stream(stream_t *s){
void free_stream(stream_t *s)
{
// printf("\n*** free_stream() called ***\n");
#ifdef CONFIG_STREAM_CACHE
cache_uninit(s);
#endif
if(s->close) s->close(s);
if(s->fd>0){
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 && strstr(s->url,"://"))
if (s->url && strstr(s->url, "://"))
closesocket(s->fd);
else close(s->fd);
else
close(s->fd);
}
#if HAVE_WINSOCK2_H
mp_msg(MSGT_STREAM,MSGL_V,"WINSOCK2 uninit\n");
mp_msg(MSGT_STREAM, MSGL_V, "WINSOCK2 uninit\n");
WSACleanup(); // there might be a better place for this (-> later)
#endif
free(s->url);
talloc_free(s);
}
stream_t* new_ds_stream(demux_stream_t *ds) {
stream_t* s = new_stream(-1,STREAMTYPE_DS);
stream_t *new_ds_stream(demux_stream_t *ds)
{
stream_t *s = new_stream(-1, STREAMTYPE_DS);
s->priv = ds;
return s;
}
@ -563,8 +595,9 @@ void stream_set_interrupt_callback(int (*cb)(struct input_ctx *, int),
stream_check_interrupt_ctx = ctx;
}
int stream_check_interrupt(int time) {
if(!stream_check_interrupt_cb) {
int stream_check_interrupt(int time)
{
if (!stream_check_interrupt_cb) {
usec_sleep(time * 1000);
return 0;
}
@ -607,14 +640,16 @@ static const uint8_t *find_newline(const uint8_t *buf, int len, int utf16)
return (uint8_t *)memchr(buf, '\n', len);
case 1:
while (buf < end - 1) {
GET_UTF16(c, buf < end - 1 ? get_le16_inc(&buf) : 0, return NULL;)
GET_UTF16(c, buf < end - 1 ? get_le16_inc(&buf) : 0, return NULL;
)
if (buf <= end && c == '\n')
return buf - 1;
}
break;
case 2:
while (buf < end - 1) {
GET_UTF16(c, buf < end - 1 ? get_be16_inc(&buf) : 0, return NULL;)
GET_UTF16(c, buf < end - 1 ? get_be16_inc(&buf) : 0, return NULL;
)
if (buf <= end && c == '\n')
return buf - 1;
}
@ -647,16 +682,20 @@ static int copy_characters(uint8_t *dst, int dstsize,
case 1:
while (src < end - 1 && dst_end - dst > 8) {
uint8_t tmp;
GET_UTF16(c, src < end - 1 ? get_le16_inc(&src) : 0, ;)
PUT_UTF8(c, tmp, *dst++ = tmp;)
GET_UTF16(c, src < end - 1 ? get_le16_inc(&src) : 0,;
)
PUT_UTF8(c, tmp, *dst++ = tmp;
)
}
*len -= end - src;
return dstsize - (dst_end - dst);
case 2:
while (src < end - 1 && dst_end - dst > 8) {
uint8_t tmp;
GET_UTF16(c, src < end - 1 ? get_be16_inc(&src) : 0, ;)
PUT_UTF8(c, tmp, *dst++ = tmp;)
GET_UTF16(c, src < end - 1 ? get_be16_inc(&src) : 0,;
)
PUT_UTF8(c, tmp, *dst++ = tmp;
)
}
*len -= end - src;
return dstsize - (dst_end - dst);
@ -664,31 +703,38 @@ static int copy_characters(uint8_t *dst, int dstsize,
return 0;
}
unsigned char* stream_read_line(stream_t *s,unsigned char* mem, int max, int utf16) {
unsigned char *stream_read_line(stream_t *s, unsigned char *mem, int max,
int utf16)
{
int len;
const unsigned char *end;
unsigned char *ptr = mem;
if (max < 1) return NULL;
if (max < 1)
return NULL;
max--; // reserve one for 0-termination
do {
len = s->buf_len-s->buf_pos;
len = s->buf_len - s->buf_pos;
// try to fill the buffer
if(len <= 0 &&
if (len <= 0 &&
(!cache_stream_fill_buffer(s) ||
(len = s->buf_len-s->buf_pos) <= 0)) break;
end = find_newline(s->buffer+s->buf_pos, len, utf16);
if(end) len = end - (s->buffer+s->buf_pos) + 1;
if(len > 0 && max > 0) {
int l = copy_characters(ptr, max, s->buffer+s->buf_pos, &len, utf16);
(len = s->buf_len - s->buf_pos) <= 0))
break;
end = find_newline(s->buffer + s->buf_pos, len, utf16);
if (end)
len = end - (s->buffer + s->buf_pos) + 1;
if (len > 0 && max > 0) {
int l = copy_characters(ptr, max, s->buffer + s->buf_pos, &len,
utf16);
max -= l;
ptr += l;
if (!len)
break;
}
s->buf_pos += len;
} while(!end);
} while (!end);
ptr[0] = 0;
if(s->eof && ptr == mem) return NULL;
if (s->eof && ptr == mem)
return NULL;
return mem;
}
@ -703,7 +749,9 @@ struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
int padding = FFMAX(padding_bytes, 1);
char *buf = NULL;
if (s->end_pos > max_size)
return (struct bstr){NULL, 0};
return (struct bstr){
NULL, 0
};
if (s->end_pos > 0)
bufsize = s->end_pos + padding;
else
@ -716,10 +764,14 @@ struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
break;
if (bufsize > max_size) {
talloc_free(buf);
return (struct bstr){NULL, 0};
return (struct bstr){
NULL, 0
};
}
bufsize = FFMIN(bufsize + (bufsize >> 1), max_size + padding);
}
buf = talloc_realloc_size(talloc_ctx, buf, total_read + padding);
return (struct bstr){buf, total_read};
return (struct bstr){
buf, total_read
};
}

216
stream/stream.h
View File

@ -57,7 +57,7 @@
#define STREAMTYPE_AVDEVICE 21
#define STREAM_BUFFER_SIZE 2048
#define STREAM_MAX_SECTOR_SIZE (8*1024)
#define STREAM_MAX_SECTOR_SIZE (8 * 1024)
#define VCD_SECTOR_SIZE 2352
#define VCD_SECTOR_OFFS 24
@ -71,7 +71,7 @@
/// MP_STREAM_SEEK is automaticly set
#define MP_STREAM_SEEK_BW 2
#define MP_STREAM_SEEK_FW 4
#define MP_STREAM_SEEK (MP_STREAM_SEEK_BW|MP_STREAM_SEEK_FW)
#define MP_STREAM_SEEK (MP_STREAM_SEEK_BW | MP_STREAM_SEEK_FW)
//////////// Open return code
#define STREAM_REDIRECTED -2
@ -120,8 +120,10 @@ typedef struct streaming_control {
unsigned int buffer_size;
unsigned int buffer_pos;
unsigned int bandwidth; // The downstream available
int (*streaming_read)( int fd, char *buffer, int buffer_size, struct streaming_control *stream_ctrl );
int (*streaming_seek)( int fd, int64_t pos, struct streaming_control *stream_ctrl );
int (*streaming_read)(int fd, char *buffer, int buffer_size,
struct streaming_control *stream_ctrl);
int (*streaming_seek)(int fd, int64_t pos,
struct streaming_control *stream_ctrl);
void *data;
// hacks for asf
int *audio_id_ptr;
@ -137,9 +139,9 @@ typedef struct stream_info_st {
/// mode isn't used atm (ie always READ) but it shouldn't be ignored
/// opts is at least in it's defaults settings and may have been
/// altered by url parsing if enabled and the options string parsing.
int (*open)(struct stream* st, int mode, void* opts, int* file_format);
const char* protocols[MAX_STREAM_PROTOCOLS];
const void* opts;
int (*open)(struct stream *st, int mode, void *opts, int *file_format);
const char *protocols[MAX_STREAM_PROTOCOLS];
const void *opts;
int opts_url; /* If this is 1 we will parse the url as an option string
* too. Otherwise options are only parsed from the
* options string given to open_stream_plugin */
@ -147,15 +149,15 @@ typedef struct stream_info_st {
typedef struct stream {
// Read
int (*fill_buffer)(struct stream *s, char* buffer, int max_len);
int (*fill_buffer)(struct stream *s, char *buffer, int max_len);
// Write
int (*write_buffer)(struct stream *s, char* buffer, int len);
int (*write_buffer)(struct stream *s, char *buffer, int len);
// Seek
int (*seek)(struct stream *s,int64_t pos);
int (*seek)(struct stream *s, int64_t pos);
// Control
// Will be later used to let streams like dvd and cdda report
// their structure (ie tracks, chapters, etc)
int (*control)(struct stream *s,int cmd,void* arg);
int (*control)(struct stream *s, int cmd, void *arg);
// Close
void (*close)(struct stream *s);
@ -164,22 +166,24 @@ typedef struct stream {
int flags;
int sector_size; // sector size (seek will be aligned on this size if non 0)
int read_chunk; // maximum amount of data to read at once to limit latency (0 for default)
unsigned int buf_pos,buf_len;
int64_t pos,start_pos,end_pos;
unsigned int buf_pos, buf_len;
int64_t pos, start_pos, end_pos;
int eof;
int mode; //STREAM_READ or STREAM_WRITE
bool streaming; // known to be a network stream if true
int cache_size; // cache size in KB to use if enabled
bool cached; // cache active
unsigned int cache_pid;
void* cache_data;
void* priv; // used for DVD, TV, RTSP etc
char* url; // strdup() of filename/url
void *cache_data;
void *priv; // used for DVD, TV, RTSP etc
char *url; // strdup() of filename/url
char *mime_type; // when HTTP streaming is used
char *lavf_type; // name of expected demuxer type for lavf
struct MPOpts *opts;
streaming_ctrl_t *streaming_ctrl;
unsigned char buffer[STREAM_BUFFER_SIZE>STREAM_MAX_SECTOR_SIZE?STREAM_BUFFER_SIZE:STREAM_MAX_SECTOR_SIZE];
unsigned char buffer[STREAM_BUFFER_SIZE >
STREAM_MAX_SECTOR_SIZE ? STREAM_BUFFER_SIZE :
STREAM_MAX_SECTOR_SIZE];
} stream_t;
#ifdef CONFIG_NETWORKING
@ -191,154 +195,180 @@ int stream_seek_long(stream_t *s, int64_t pos);
#ifdef CONFIG_STREAM_CACHE
int stream_enable_cache_percent(stream_t *stream, int64_t stream_cache_size,
float stream_cache_min_percent, float stream_cache_seek_min_percent);
int stream_enable_cache(stream_t *stream,int64_t size,int64_t min,int64_t prefill);
float stream_cache_min_percent,
float stream_cache_seek_min_percent);
int stream_enable_cache(stream_t *stream, int64_t size, int64_t min,
int64_t prefill);
int cache_stream_fill_buffer(stream_t *s);
int cache_stream_seek_long(stream_t *s,int64_t pos);
int cache_stream_seek_long(stream_t *s, int64_t pos);
#else
// no cache, define wrappers:
#define cache_stream_fill_buffer(x) stream_fill_buffer(x)
#define cache_stream_seek_long(x,y) stream_seek_long(x,y)
#define stream_enable_cache(x,y,z,w) 1
#define stream_enable_cache_percent(x,y,z,w) 1
#define cache_stream_seek_long(x, y) stream_seek_long(x, y)
#define stream_enable_cache(x, y, z, w) 1
#define stream_enable_cache_percent(x, y, z, w) 1
#endif
int stream_write_buffer(stream_t *s, unsigned char *buf, int len);
inline static int stream_read_char(stream_t *s){
return (s->buf_pos<s->buf_len)?s->buffer[s->buf_pos++]:
(cache_stream_fill_buffer(s)?s->buffer[s->buf_pos++]:-256);
inline static int stream_read_char(stream_t *s)
{
return (s->buf_pos < s->buf_len) ? s->buffer[s->buf_pos++] :
(cache_stream_fill_buffer(s) ? s->buffer[s->buf_pos++] : -256);
// if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
// stream_fill_buffer(s);
// if(s->buf_pos<s->buf_len) return s->buffer[s->buf_pos++];
// return 0; // EOF
}
inline static unsigned int stream_read_word(stream_t *s){
int x,y;
x=stream_read_char(s);
y=stream_read_char(s);
return (x<<8)|y;
inline static unsigned int stream_read_word(stream_t *s)
{
int x, y;
x = stream_read_char(s);
y = stream_read_char(s);
return (x << 8) | y;
}
inline static unsigned int stream_read_dword(stream_t *s){
inline static unsigned int stream_read_dword(stream_t *s)
{
unsigned int y;
y=stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y = stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
return y;
}
#define stream_read_fourcc stream_read_dword_le
inline static unsigned int stream_read_word_le(stream_t *s){
int x,y;
x=stream_read_char(s);
y=stream_read_char(s);
return (y<<8)|x;
inline static unsigned int stream_read_word_le(stream_t *s)
{
int x, y;
x = stream_read_char(s);
y = stream_read_char(s);
return (y << 8) | x;
}
inline static uint32_t stream_read_dword_le(stream_t *s)
{
unsigned int y;
y=stream_read_char(s);
y|=stream_read_char(s)<<8;
y|=stream_read_char(s)<<16;
y|=stream_read_char(s)<<24;
y = stream_read_char(s);
y |= stream_read_char(s) << 8;
y |= stream_read_char(s) << 16;
y |= stream_read_char(s) << 24;
return y;
}
inline static uint64_t stream_read_qword(stream_t *s){
inline static uint64_t stream_read_qword(stream_t *s)
{
uint64_t y;
y = stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
return y;
}
inline static uint64_t stream_read_qword_le(stream_t *s){
inline static uint64_t stream_read_qword_le(stream_t *s)
{
uint64_t y;
y = stream_read_dword_le(s);
y|=(uint64_t)stream_read_dword_le(s)<<32;
y |= (uint64_t)stream_read_dword_le(s) << 32;
return y;
}
inline static unsigned int stream_read_int24(stream_t *s){
inline static unsigned int stream_read_int24(stream_t *s)
{
unsigned int y;
y = stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y=(y<<8)|stream_read_char(s);
y = (y << 8) | stream_read_char(s);
y = (y << 8) | stream_read_char(s);
return y;
}
inline static int stream_read(stream_t *s,char* mem,int total){
int len=total;
while(len>0){
inline static int stream_read(stream_t *s, char *mem, int total)
{
int len = total;
while (len > 0) {
int x;
x=s->buf_len-s->buf_pos;
if(x==0){
if(!cache_stream_fill_buffer(s)) return total-len; // EOF
x=s->buf_len-s->buf_pos;
x = s->buf_len - s->buf_pos;
if (x == 0) {
if (!cache_stream_fill_buffer(s))
return total - len; // EOF
x = s->buf_len - s->buf_pos;
}
if(s->buf_pos>s->buf_len) mp_msg(MSGT_DEMUX, MSGL_WARN, "stream_read: WARNING! s->buf_pos>s->buf_len\n");
if(x>len) x=len;
memcpy(mem,&s->buffer[s->buf_pos],x);
s->buf_pos+=x; mem+=x; len-=x;
if (s->buf_pos > s->buf_len)
mp_msg(MSGT_DEMUX, MSGL_WARN,
"stream_read: WARNING! s->buf_pos>s->buf_len\n");
if (x > len)
x = len;
memcpy(mem, &s->buffer[s->buf_pos], x);
s->buf_pos += x;
mem += x;
len -= x;
}
return total;
}
unsigned char* stream_read_line(stream_t *s,unsigned char* mem, int max, int utf16);
unsigned char *stream_read_line(stream_t *s, unsigned char *mem, int max,
int utf16);
inline static int stream_eof(stream_t *s){
inline static int stream_eof(stream_t *s)
{
return s->eof;
}
inline static int64_t stream_tell(stream_t *s){
return s->pos+s->buf_pos-s->buf_len;
inline static int64_t stream_tell(stream_t *s)
{
return s->pos + s->buf_pos - s->buf_len;
}
inline static int stream_seek(stream_t *s,int64_t pos){
inline static int stream_seek(stream_t *s, int64_t pos)
{
mp_dbg(MSGT_DEMUX, MSGL_DBG3, "seek to 0x%llX\n", (long long)pos);
if (pos < 0) {
mp_msg(MSGT_DEMUX, MSGL_ERR, "Invalid seek to negative position %llx!\n",
mp_msg(MSGT_DEMUX, MSGL_ERR,
"Invalid seek to negative position %llx!\n",
(long long)pos);
pos = 0;
}
if(pos<s->pos){
int64_t x=pos-(s->pos-s->buf_len);
if(x>=0){
s->buf_pos=x;
if (pos < s->pos) {
int64_t x = pos - (s->pos - s->buf_len);
if (x >= 0) {
s->buf_pos = x;
s->eof = 0;
// putchar('*');fflush(stdout);
return 1;
}
}
return cache_stream_seek_long(s,pos);
return cache_stream_seek_long(s, pos);
}
inline static int stream_skip(stream_t *s,int64_t len){
if( len<0 || (len>2*STREAM_BUFFER_SIZE && (s->flags & MP_STREAM_SEEK_FW)) ) {
inline static int stream_skip(stream_t *s, int64_t len)
{
if (len < 0 ||
(len > 2 * STREAM_BUFFER_SIZE && (s->flags & MP_STREAM_SEEK_FW))) {
// negative or big skip!
return stream_seek(s,stream_tell(s)+len);
return stream_seek(s, stream_tell(s) + len);
}
while(len>0){
int x=s->buf_len-s->buf_pos;
if(x==0){
if(!cache_stream_fill_buffer(s)) return 0; // EOF
x=s->buf_len-s->buf_pos;
while (len > 0) {
int x = s->buf_len - s->buf_pos;
if (x == 0) {
if (!cache_stream_fill_buffer(s))
return 0; // EOF
x = s->buf_len - s->buf_pos;
}
if(x>len) x=len;
if (x > len)
x = len;
//memcpy(mem,&s->buf[s->buf_pos],x);
s->buf_pos+=x; len-=x;
s->buf_pos += x;
len -= x;
}
return 1;
}
@ -355,9 +385,9 @@ struct bstr stream_read_complete(struct stream *s, void *talloc_ctx,
void stream_reset(stream_t *s);
int stream_control(stream_t *s, int cmd, void *arg);
void stream_update_size(stream_t *s);
stream_t* new_stream(int fd,int type);
stream_t *new_stream(int fd, int type);
void free_stream(stream_t *s);
stream_t* new_memory_stream(unsigned char* data,int len);
stream_t *new_memory_stream(unsigned char *data, int len);
stream_t *open_stream(const char *filename, struct MPOpts *options,
int *file_format);
stream_t *open_output_stream(const char *filename, struct MPOpts *options);
@ -367,7 +397,7 @@ struct stream *new_ds_stream(struct demux_stream *ds);
/// Set the callback to be used by libstream to check for user
/// interruption during long blocking operations (cache filling, etc).
struct input_ctx;
void stream_set_interrupt_callback(int (*cb)(struct input_ctx*, int),
void stream_set_interrupt_callback(int (*cb)(struct input_ctx *, int),
struct input_ctx *ctx);
/// Call the interrupt checking callback if there is one and
/// wait for time milliseconds