annotate stream/cache2.c @ 34697:ac6b38cd0d45

Rename sub window video window. It was a bad idea to name the video window "sub window" at the time the GUI was written. The term "sub window" does make sense from the programmer's point of view, but it doesn't make any sense at all from the user's point of view, because the sub window simply is the window where the video will be displayed. Moreover, since the term "sub" is generally short for "subtitles", the renaming makes the code much easier to understand.
author ib
date Sat, 03 Mar 2012 16:45:15 +0000
parents 26eddbd6353a
children 4ccdcd1ff6ba
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
30426
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
1 /*
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
2 * This file is part of MPlayer.
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
3 *
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
4 * MPlayer is free software; you can redistribute it and/or modify
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
5 * it under the terms of the GNU General Public License as published by
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
6 * the Free Software Foundation; either version 2 of the License, or
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
7 * (at your option) any later version.
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
8 *
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
9 * MPlayer is distributed in the hope that it will be useful,
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
12 * GNU General Public License for more details.
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
13 *
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
14 * You should have received a copy of the GNU General Public License along
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
17 */
ce0122361a39 Add license header to all files missing it in the stream subdirectory.
diego
parents: 30362
diff changeset
18
2324
0e4210657f0e ehh. include config.h... 10l
arpi
parents: 2322
diff changeset
19 #include "config.h"
0e4210657f0e ehh. include config.h... 10l
arpi
parents: 2322
diff changeset
20
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
21 // Initial draft of my new cache system...
31181
e735964b5d56 Fix a bunch of typos in the stream cache code.
diego
parents: 31169
diff changeset
22 // Note it runs in 2 processes (using fork()), but doesn't require locking!!
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
23 // TODO: seeking, data consistency checking
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
24
31193
f41fda4fe85f 100l, stream_check_for_interrupt argument is not in usec,
reimar
parents: 31190
diff changeset
25 #define READ_SLEEP_TIME 10
31181
e735964b5d56 Fix a bunch of typos in the stream cache code.
diego
parents: 31169
diff changeset
26 // These defines are used to reduce the cost of many successive
31142
355302f83219 Optimize cache behaviour for the many-consecutive-seeks case.
reimar
parents: 31141
diff changeset
27 // seeks (e.g. when a file has no index) by spinning quickly at first.
355302f83219 Optimize cache behaviour for the many-consecutive-seeks case.
reimar
parents: 31141
diff changeset
28 #define INITIAL_FILL_USLEEP_TIME 1000
355302f83219 Optimize cache behaviour for the many-consecutive-seeks case.
reimar
parents: 31141
diff changeset
29 #define INITIAL_FILL_USLEEP_COUNT 10
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
30 #define FILL_USLEEP_TIME 50000
4825
41d2da3bd082 Make blocking call in libmpdemux interuptable (only with new input,
albeu
parents: 3726
diff changeset
31 #define PREFILL_SLEEP_TIME 200
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
32 #define CONTROL_SLEEP_TIME 0
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
33
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
34 #include <stdio.h>
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
35 #include <stdlib.h>
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
36 #include <string.h>
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
37 #include <signal.h>
3726
1acf2f1f9dc8 missing #include's
pl
parents: 3600
diff changeset
38 #include <sys/types.h>
1acf2f1f9dc8 missing #include's
pl
parents: 3600
diff changeset
39 #include <unistd.h>
30351
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
40 #include <errno.h>
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
41
32529
0624fa95a2aa Make the file protocol read up to 64 kB at once when the cache is used,
reimar
parents: 32472
diff changeset
42 #include "libavutil/avutil.h"
27723
fb67a8f56bfc Unconditionally #include osdep/shem.h, fixes the warnings on Cygwin:
diego
parents: 27343
diff changeset
43 #include "osdep/shmem.h"
17012
6ff3379a0862 Unify include path handling, -I.. is in CFLAGS.
diego
parents: 16870
diff changeset
44 #include "osdep/timer.h"
27894
d06d8e459ae1 Use pthreads for the cache on Cygwin, since _beginthread is not available
reimar
parents: 27876
diff changeset
45 #if defined(__MINGW32__)
26077
d8128689c031 cache support for OS/2
diego
parents: 25445
diff changeset
46 #include <windows.h>
27770
c8d4cace053d Avoid CreateThread and especially TerminateThread since they cause a memleak.
reimar
parents: 27769
diff changeset
47 static void ThreadProc( void *s );
26077
d8128689c031 cache support for OS/2
diego
parents: 25445
diff changeset
48 #elif defined(__OS2__)
d8128689c031 cache support for OS/2
diego
parents: 25445
diff changeset
49 #define INCL_DOS
d8128689c031 cache support for OS/2
diego
parents: 25445
diff changeset
50 #include <os2.h>
27756
1266470a5651 Revert declaring ThreadProc as void, it breaks the WINAPI.
diego
parents: 27727
diff changeset
51 static void ThreadProc( void *s );
27894
d06d8e459ae1 Use pthreads for the cache on Cygwin, since _beginthread is not available
reimar
parents: 27876
diff changeset
52 #elif defined(PTHREAD_CACHE)
d06d8e459ae1 Use pthreads for the cache on Cygwin, since _beginthread is not available
reimar
parents: 27876
diff changeset
53 #include <pthread.h>
d06d8e459ae1 Use pthreads for the cache on Cygwin, since _beginthread is not available
reimar
parents: 27876
diff changeset
54 static void *ThreadProc(void *s);
26077
d8128689c031 cache support for OS/2
diego
parents: 25445
diff changeset
55 #else
10242
4e34d468f549 warning fixes by Dominik
alex
parents: 10197
diff changeset
56 #include <sys/wait.h>
31146
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
57 #define FORKED_CACHE 1
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
58 #endif
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
59 #ifndef FORKED_CACHE
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
60 #define FORKED_CACHE 0
10197
9e11a478a3bc use threads on windows
faust3
parents: 9915
diff changeset
61 #endif
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
62
2371
0f2cad867121 printf->mp_msg
arpi
parents: 2352
diff changeset
63 #include "mp_msg.h"
16793
8d4fb5469efb Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents: 16750
diff changeset
64 #include "help_mp.h"
2371
0f2cad867121 printf->mp_msg
arpi
parents: 2352
diff changeset
65
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
66 #include "stream.h"
27876
298a3cd86bbb Include cache2.h in cache2.c, fixes an implicit declaration warning for cache_do_control
reimar
parents: 27770
diff changeset
67 #include "cache2.h"
33517
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
68 #include "mp_global.h"
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
69
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
70 typedef struct {
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
71 // constats:
31181
e735964b5d56 Fix a bunch of typos in the stream cache code.
diego
parents: 31169
diff changeset
72 unsigned char *buffer; // base pointer of the allocated buffer memory
e735964b5d56 Fix a bunch of typos in the stream cache code.
diego
parents: 31169
diff changeset
73 int buffer_size; // size of the allocated buffer memory
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
74 int sector_size; // size of a single sector (2048/2324)
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
75 int back_size; // we should keep back_size amount of old bytes for backward seek
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
76 int fill_limit; // we should fill buffer only if space>=fill_limit
31181
e735964b5d56 Fix a bunch of typos in the stream cache code.
diego
parents: 31169
diff changeset
77 int seek_limit; // keep filling cache if distance is less that seek limit
34283
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
78 #if FORKED_CACHE
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
79 pid_t ppid; // parent PID to detect killed parent
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
80 #endif
2374
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
81 // filler's pointers:
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
82 int eof;
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
83 off_t min_filepos; // buffer contain only a part of the file, from min-max pos
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
84 off_t max_filepos;
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
85 off_t offset; // filepos <-> bufferpos offset value (filepos of the buffer's first byte)
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
86 // reader's pointers:
2374
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
87 off_t read_filepos;
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
88 // commands/locking:
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
89 // int seek_lock; // 1 if we will seek/reset buffer, 2 if we are ready for cmd
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
90 // int fifo_flag; // 1 if we should use FIFO to notice cache about buffer reads.
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
91 // callback
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
92 stream_t* stream;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
93 volatile int control;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
94 volatile unsigned control_uint_arg;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
95 volatile double control_double_arg;
34648
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
96 volatile struct stream_lang_req control_lang_arg;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
97 volatile int control_res;
26847
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
98 volatile double stream_time_length;
33517
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
99 volatile double stream_time_pos;
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
100 } cache_vars_t;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
101
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
102 static int min_fill=0;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
103
31141
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
104 static void cache_wakeup(stream_t *s)
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
105 {
31146
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
106 #if FORKED_CACHE
31141
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
107 // signal process to wake up immediately
31167
09e3134b649d Re-enable wakeup-on-signal for cache process.
reimar
parents: 31166
diff changeset
108 kill(s->cache_pid, SIGUSR1);
31141
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
109 #endif
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
110 }
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
111
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
112 static void cache_flush(cache_vars_t *s)
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
113 {
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
114 s->offset= // FIXME!?
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
115 s->min_filepos=s->max_filepos=s->read_filepos; // drop cache content :(
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
116 }
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
117
30557
74a6c2a3dcce stream: Mark functions not used outside of their files as static.
diego
parents: 30426
diff changeset
118 static int cache_read(cache_vars_t *s, unsigned char *buf, int size)
74a6c2a3dcce stream: Mark functions not used outside of their files as static.
diego
parents: 30426
diff changeset
119 {
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
120 int total=0;
31190
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
121 int sleep_count = 0;
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
122 int last_max = s->max_filepos;
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
123 while(size>0){
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
124 int pos,newb,len;
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
125
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
126 //printf("CACHE2_READ: 0x%X <= 0x%X <= 0x%X \n",s->min_filepos,s->read_filepos,s->max_filepos);
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
127
2374
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
128 if(s->read_filepos>=s->max_filepos || s->read_filepos<s->min_filepos){
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
129 // eof?
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
130 if(s->eof) break;
31190
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
131 if (s->max_filepos == last_max) {
31193
f41fda4fe85f 100l, stream_check_for_interrupt argument is not in usec,
reimar
parents: 31190
diff changeset
132 if (sleep_count++ == 10)
33868
1714e25ded23 Another attempt to make message easier to understand.
reimar
parents: 33867
diff changeset
133 mp_msg(MSGT_CACHE, MSGL_WARN, "Cache empty, consider increasing -cache and/or -cache-min. [performance issue]\n");
31190
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
134 } else {
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
135 last_max = s->max_filepos;
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
136 sleep_count = 0;
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
137 }
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
138 // waiting for buffer fill...
31193
f41fda4fe85f 100l, stream_check_for_interrupt argument is not in usec,
reimar
parents: 31190
diff changeset
139 if (stream_check_interrupt(READ_SLEEP_TIME)) {
31190
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
140 s->eof = 1;
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
141 break;
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
142 }
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
143 continue; // try again...
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
144 }
31190
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
145 sleep_count = 0;
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
146
2374
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
147 newb=s->max_filepos-s->read_filepos; // new bytes in the buffer
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
148 if(newb<min_fill) min_fill=newb; // statistics...
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
149
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
150 // printf("*** newb: %d bytes ***\n",newb);
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
151
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
152 pos=s->read_filepos - s->offset;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
153 if(pos<0) pos+=s->buffer_size; else
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
154 if(pos>=s->buffer_size) pos-=s->buffer_size;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
155
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
156 if(newb>s->buffer_size-pos) newb=s->buffer_size-pos; // handle wrap...
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
157 if(newb>size) newb=size;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
158
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
159 // check:
2371
0f2cad867121 printf->mp_msg
arpi
parents: 2352
diff changeset
160 if(s->read_filepos<s->min_filepos) mp_msg(MSGT_CACHE,MSGL_ERR,"Ehh. s->read_filepos<s->min_filepos !!! Report bug...\n");
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
161
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
162 // len=write(mem,newb)
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
163 //printf("Buffer read: %d bytes\n",newb);
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
164 memcpy(buf,&s->buffer[pos],newb);
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
165 buf+=newb;
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
166 len=newb;
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
167 // ...
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
168
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
169 s->read_filepos+=len;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
170 size-=len;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
171 total+=len;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
172
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
173 }
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
174 return total;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
175 }
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
176
30557
74a6c2a3dcce stream: Mark functions not used outside of their files as static.
diego
parents: 30426
diff changeset
177 static int cache_fill(cache_vars_t *s)
74a6c2a3dcce stream: Mark functions not used outside of their files as static.
diego
parents: 30426
diff changeset
178 {
7472
c4434bdf6e51 tons of warning fixes, also some 10l bugfixes, including Dominik's PVA bug
arpi
parents: 7204
diff changeset
179 int back,back2,newb,space,len,pos;
2374
eb6f70125851 largefileization
arpi
parents: 2371
diff changeset
180 off_t read=s->read_filepos;
32529
0624fa95a2aa Make the file protocol read up to 64 kB at once when the cache is used,
reimar
parents: 32472
diff changeset
181 int read_chunk;
33033
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
182 int wraparound_copy = 0;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
183
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
184 if(read<s->min_filepos || read>s->max_filepos){
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
185 // seek...
17366
934380353fd6 massive attack: mp_msg printf format fixes
rathann
parents: 17012
diff changeset
186 mp_msg(MSGT_CACHE,MSGL_DBG2,"Out of boundaries... seeking to 0x%"PRIX64" \n",(int64_t)read);
31305
7ae56026b7ee Respect -cache-seek-min also for on-disk files to reduce issues with mov.
reimar
parents: 31195
diff changeset
187 // drop cache contents only if seeking backward or too much fwd.
7ae56026b7ee Respect -cache-seek-min also for on-disk files to reduce issues with mov.
reimar
parents: 31195
diff changeset
188 // This is also done for on-disk files, since it loses the backseek cache.
7ae56026b7ee Respect -cache-seek-min also for on-disk files to reduce issues with mov.
reimar
parents: 31195
diff changeset
189 // That in turn can cause major bandwidth increase and performance
7ae56026b7ee Respect -cache-seek-min also for on-disk files to reduce issues with mov.
reimar
parents: 31195
diff changeset
190 // issues with e.g. mov or badly interleaved files
7ae56026b7ee Respect -cache-seek-min also for on-disk files to reduce issues with mov.
reimar
parents: 31195
diff changeset
191 if(read<s->min_filepos || read>=s->max_filepos+s->seek_limit)
8938
fc21a94f98c6 do not discard cache content at seeking type=STREAMTYPE_STREAM
arpi
parents: 7862
diff changeset
192 {
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
193 cache_flush(s);
8938
fc21a94f98c6 do not discard cache content at seeking type=STREAMTYPE_STREAM
arpi
parents: 7862
diff changeset
194 if(s->stream->eof) stream_reset(s->stream);
32472
5d1d67cf8718 Add internal read and seek function to avoid a useless memcpy when using
reimar
parents: 32468
diff changeset
195 stream_seek_internal(s->stream,read);
17366
934380353fd6 massive attack: mp_msg printf format fixes
rathann
parents: 17012
diff changeset
196 mp_msg(MSGT_CACHE,MSGL_DBG2,"Seek done. new pos: 0x%"PRIX64" \n",(int64_t)stream_tell(s->stream));
8938
fc21a94f98c6 do not discard cache content at seeking type=STREAMTYPE_STREAM
arpi
parents: 7862
diff changeset
197 }
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
198 }
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
199
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
200 // calc number of back-bytes:
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
201 back=read - s->min_filepos;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
202 if(back<0) back=0; // strange...
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
203 if(back>s->back_size) back=s->back_size;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
204
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
205 // calc number of new bytes:
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
206 newb=s->max_filepos - read;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
207 if(newb<0) newb=0; // strange...
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
208
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
209 // calc free buffer space:
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
210 space=s->buffer_size - (newb+back);
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
211
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
212 // calc bufferpos:
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
213 pos=s->max_filepos - s->offset;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
214 if(pos>=s->buffer_size) pos-=s->buffer_size; // wrap-around
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
215
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
216 if(space<s->fill_limit){
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
217 // printf("Buffer is full (%d bytes free, limit: %d)\n",space,s->fill_limit);
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
218 return 0; // no fill...
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
219 }
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
220
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
221 // printf("### read=0x%X back=%d newb=%d space=%d pos=%d\n",read,back,newb,space,pos);
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
222
33033
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
223 // try to avoid wrap-around. If not possible due to sector size
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
224 // do an extra copy.
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
225 if(space>s->buffer_size-pos) {
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
226 if (s->buffer_size-pos >= s->sector_size) {
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
227 space=s->buffer_size-pos;
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
228 } else {
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
229 space = s->sector_size;
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
230 wraparound_copy = 1;
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
231 }
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
232 }
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
233
32468
0c7c4ed0b7eb Remove som irrelevant commented-out code.
reimar
parents: 32438
diff changeset
234 // limit one-time block size
32529
0624fa95a2aa Make the file protocol read up to 64 kB at once when the cache is used,
reimar
parents: 32472
diff changeset
235 read_chunk = s->stream->read_chunk;
0624fa95a2aa Make the file protocol read up to 64 kB at once when the cache is used,
reimar
parents: 32472
diff changeset
236 if (!read_chunk) read_chunk = 4*s->sector_size;
0624fa95a2aa Make the file protocol read up to 64 kB at once when the cache is used,
reimar
parents: 32472
diff changeset
237 space = FFMIN(space, read_chunk);
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
238
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
239 #if 1
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
240 // back+newb+space <= buffer_size
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
241 back2=s->buffer_size-(space+newb); // max back size
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
242 if(s->min_filepos<(read-back2)) s->min_filepos=read-back2;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
243 #else
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
244 s->min_filepos=read-back; // avoid seeking-back to temp area...
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
245 #endif
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
246
33033
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
247 if (wraparound_copy) {
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
248 int to_copy;
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
249 len = stream_read_internal(s->stream, s->stream->buffer, space);
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
250 to_copy = FFMIN(len, s->buffer_size-pos);
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
251 memcpy(s->buffer + pos, s->stream->buffer, to_copy);
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
252 memcpy(s->buffer, s->stream->buffer + to_copy, len - to_copy);
1aed51b973fa Ensure we always pass a buffer of at least sector size to the read function.
reimar
parents: 32731
diff changeset
253 } else
32472
5d1d67cf8718 Add internal read and seek function to avoid a useless memcpy when using
reimar
parents: 32468
diff changeset
254 len = stream_read_internal(s->stream, &s->buffer[pos], space);
31169
ac84149bbdaf Retry reading even if we hit eof before.
reimar
parents: 31167
diff changeset
255 s->eof= !len;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
256
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
257 s->max_filepos+=len;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
258 if(pos+len>=s->buffer_size){
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
259 // wrap...
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
260 s->offset+=s->buffer_size;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
261 }
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
262
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
263 return len;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
264
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
265 }
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
266
27770
c8d4cace053d Avoid CreateThread and especially TerminateThread since they cause a memleak.
reimar
parents: 27769
diff changeset
267 static int cache_execute_control(cache_vars_t *s) {
33348
62ab329812c9 Avoid warnings about discarding volatile.
reimar
parents: 33033
diff changeset
268 double double_res;
62ab329812c9 Avoid warnings about discarding volatile.
reimar
parents: 33033
diff changeset
269 unsigned uint_res;
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
270 int needs_flush = 0;
26847
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
271 static unsigned last;
30731
5a1ab9923c3a Threaded cache fixes: do not free the stream_t struct twice on windows
reimar
parents: 30712
diff changeset
272 int quit = s->control == -2;
34488
01c19d9b1e83 Print an error when streams behave in a way that the cache cannot handle.
reimar
parents: 34487
diff changeset
273 uint64_t old_pos = s->stream->pos;
01c19d9b1e83 Print an error when streams behave in a way that the cache cannot handle.
reimar
parents: 34487
diff changeset
274 int old_eof = s->stream->eof;
30731
5a1ab9923c3a Threaded cache fixes: do not free the stream_t struct twice on windows
reimar
parents: 30712
diff changeset
275 if (quit || !s->stream->control) {
26897
23c3741dc490 Handle NULL control function in cache_execute_control, fixes crash with http urls.
reimar
parents: 26847
diff changeset
276 s->stream_time_length = 0;
33517
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
277 s->stream_time_pos = MP_NOPTS_VALUE;
26897
23c3741dc490 Handle NULL control function in cache_execute_control, fixes crash with http urls.
reimar
parents: 26847
diff changeset
278 s->control_res = STREAM_UNSUPPORTED;
23c3741dc490 Handle NULL control function in cache_execute_control, fixes crash with http urls.
reimar
parents: 26847
diff changeset
279 s->control = -1;
30731
5a1ab9923c3a Threaded cache fixes: do not free the stream_t struct twice on windows
reimar
parents: 30712
diff changeset
280 return !quit;
26897
23c3741dc490 Handle NULL control function in cache_execute_control, fixes crash with http urls.
reimar
parents: 26847
diff changeset
281 }
26847
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
282 if (GetTimerMS() - last > 99) {
33517
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
283 double len, pos;
26847
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
284 if (s->stream->control(s->stream, STREAM_CTRL_GET_TIME_LENGTH, &len) == STREAM_OK)
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
285 s->stream_time_length = len;
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
286 else
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
287 s->stream_time_length = 0;
33517
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
288 if (s->stream->control(s->stream, STREAM_CTRL_GET_CURRENT_TIME, &pos) == STREAM_OK)
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
289 s->stream_time_pos = pos;
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
290 else
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
291 s->stream_time_pos = MP_NOPTS_VALUE;
34283
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
292 #if FORKED_CACHE
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
293 // if parent PID changed, main process was killed -> exit
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
294 if (s->ppid != getppid()) {
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
295 mp_msg(MSGT_CACHE, MSGL_WARN, "Parent process disappeared, exiting cache process.\n");
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
296 return 0;
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
297 }
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
298 #endif
26847
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
299 last = GetTimerMS();
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
300 }
30731
5a1ab9923c3a Threaded cache fixes: do not free the stream_t struct twice on windows
reimar
parents: 30712
diff changeset
301 if (s->control == -1) return 1;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
302 switch (s->control) {
33360
c36ab8db37f6 100l, fix seek cache controls with cache enabled,
reimar
parents: 33348
diff changeset
303 case STREAM_CTRL_SEEK_TO_TIME:
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
304 needs_flush = 1;
33360
c36ab8db37f6 100l, fix seek cache controls with cache enabled,
reimar
parents: 33348
diff changeset
305 double_res = s->control_double_arg;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
306 case STREAM_CTRL_GET_CURRENT_TIME:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
307 case STREAM_CTRL_GET_ASPECT_RATIO:
33348
62ab329812c9 Avoid warnings about discarding volatile.
reimar
parents: 33033
diff changeset
308 s->control_res = s->stream->control(s->stream, s->control, &double_res);
62ab329812c9 Avoid warnings about discarding volatile.
reimar
parents: 33033
diff changeset
309 s->control_double_arg = double_res;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
310 break;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
311 case STREAM_CTRL_SEEK_TO_CHAPTER:
33360
c36ab8db37f6 100l, fix seek cache controls with cache enabled,
reimar
parents: 33348
diff changeset
312 case STREAM_CTRL_SET_ANGLE:
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
313 needs_flush = 1;
33360
c36ab8db37f6 100l, fix seek cache controls with cache enabled,
reimar
parents: 33348
diff changeset
314 uint_res = s->control_uint_arg;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
315 case STREAM_CTRL_GET_NUM_CHAPTERS:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
316 case STREAM_CTRL_GET_CURRENT_CHAPTER:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
317 case STREAM_CTRL_GET_NUM_ANGLES:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
318 case STREAM_CTRL_GET_ANGLE:
33348
62ab329812c9 Avoid warnings about discarding volatile.
reimar
parents: 33033
diff changeset
319 s->control_res = s->stream->control(s->stream, s->control, &uint_res);
62ab329812c9 Avoid warnings about discarding volatile.
reimar
parents: 33033
diff changeset
320 s->control_uint_arg = uint_res;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
321 break;
34648
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
322 case STREAM_CTRL_GET_LANG:
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
323 s->control_res = s->stream->control(s->stream, s->control, (void *)&s->control_lang_arg);
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
324 break;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
325 default:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
326 s->control_res = STREAM_UNSUPPORTED;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
327 break;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
328 }
34487
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
329 if (s->control_res == STREAM_OK && needs_flush) {
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
330 s->read_filepos = s->stream->pos;
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
331 s->eof = s->stream->eof;
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
332 cache_flush(s);
34488
01c19d9b1e83 Print an error when streams behave in a way that the cache cannot handle.
reimar
parents: 34487
diff changeset
333 } else if (needs_flush &&
01c19d9b1e83 Print an error when streams behave in a way that the cache cannot handle.
reimar
parents: 34487
diff changeset
334 (old_pos != s->stream->pos || old_eof != s->stream->eof))
01c19d9b1e83 Print an error when streams behave in a way that the cache cannot handle.
reimar
parents: 34487
diff changeset
335 mp_msg(MSGT_STREAM, MSGL_ERR, "STREAM_CTRL changed stream pos but returned error, this is not allowed!\n");
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
336 s->control = -1;
30731
5a1ab9923c3a Threaded cache fixes: do not free the stream_t struct twice on windows
reimar
parents: 30712
diff changeset
337 return 1;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
338 }
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
339
31147
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
340 static void *shared_alloc(int size) {
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
341 #if FORKED_CACHE
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
342 return shmem_alloc(size);
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
343 #else
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
344 return malloc(size);
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
345 #endif
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
346 }
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
347
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
348 static void shared_free(void *ptr, int size) {
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
349 #if FORKED_CACHE
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
350 shmem_free(ptr, size);
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
351 #else
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
352 free(ptr);
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
353 #endif
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
354 }
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
355
30359
44b8f698fd15 Make cache_init static, it is not used outside this file
reimar
parents: 30355
diff changeset
356 static cache_vars_t* cache_init(int size,int sector){
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
357 int num;
31147
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
358 cache_vars_t* s=shared_alloc(sizeof(cache_vars_t));
12899
061dd89b6a23 prevent segfault on shmem failer
iive
parents: 12835
diff changeset
359 if(s==NULL) return NULL;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
360
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
361 memset(s,0,sizeof(cache_vars_t));
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
362 num=size/sector;
12835
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
363 if(num < 16){
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
364 num = 16;
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
365 }//32kb min_size
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
366 s->buffer_size=num*sector;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
367 s->sector_size=sector;
31147
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
368 s->buffer=shared_alloc(s->buffer_size);
12899
061dd89b6a23 prevent segfault on shmem failer
iive
parents: 12835
diff changeset
369
061dd89b6a23 prevent segfault on shmem failer
iive
parents: 12835
diff changeset
370 if(s->buffer == NULL){
31147
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
371 shared_free(s, sizeof(cache_vars_t));
12899
061dd89b6a23 prevent segfault on shmem failer
iive
parents: 12835
diff changeset
372 return NULL;
061dd89b6a23 prevent segfault on shmem failer
iive
parents: 12835
diff changeset
373 }
061dd89b6a23 prevent segfault on shmem failer
iive
parents: 12835
diff changeset
374
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
375 s->fill_limit=8*sector;
12835
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
376 s->back_size=s->buffer_size/2;
34283
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
377 #if FORKED_CACHE
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
378 s->ppid = getpid();
3a4adac4e9a5 Make cache process detect when the main process disappeared and
reimar
parents: 33868
diff changeset
379 #endif
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
380 return s;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
381 }
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
382
9915
eabe876ab5e2 Fix cache uninit
albeu
parents: 9380
diff changeset
383 void cache_uninit(stream_t *s) {
eabe876ab5e2 Fix cache uninit
albeu
parents: 9380
diff changeset
384 cache_vars_t* c = s->cache_data;
30351
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
385 if(s->cache_pid) {
31146
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
386 #if !FORKED_CACHE
30353
3c131287a33e Reindent.
reimar
parents: 30352
diff changeset
387 cache_do_control(s, -2, NULL);
26077
d8128689c031 cache support for OS/2
diego
parents: 25445
diff changeset
388 #else
30353
3c131287a33e Reindent.
reimar
parents: 30352
diff changeset
389 kill(s->cache_pid,SIGKILL);
3c131287a33e Reindent.
reimar
parents: 30352
diff changeset
390 waitpid(s->cache_pid,NULL,0);
10197
9e11a478a3bc use threads on windows
faust3
parents: 9915
diff changeset
391 #endif
30352
dff74677e2fd Zero freed pointers.
reimar
parents: 30351
diff changeset
392 s->cache_pid = 0;
30351
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
393 }
9915
eabe876ab5e2 Fix cache uninit
albeu
parents: 9380
diff changeset
394 if(!c) return;
31147
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
395 shared_free(c->buffer, c->buffer_size);
30354
1b2de14c5233 100l, shouldn't write to memory after freeing it.
reimar
parents: 30353
diff changeset
396 c->buffer = NULL;
30731
5a1ab9923c3a Threaded cache fixes: do not free the stream_t struct twice on windows
reimar
parents: 30712
diff changeset
397 c->stream = NULL;
31147
97660f5d9aef Slightly reduce number of #ifs
reimar
parents: 31146
diff changeset
398 shared_free(s->cache_data, sizeof(cache_vars_t));
30352
dff74677e2fd Zero freed pointers.
reimar
parents: 30351
diff changeset
399 s->cache_data = NULL;
9915
eabe876ab5e2 Fix cache uninit
albeu
parents: 9380
diff changeset
400 }
eabe876ab5e2 Fix cache uninit
albeu
parents: 9380
diff changeset
401
33617
c77bf171b354 cache2: Surround conditionally used functions by appropriate #ifdefs.
diego
parents: 33517
diff changeset
402 #if FORKED_CACHE
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
403 static void exit_sighandler(int x){
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
404 // close stream
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
405 exit(0);
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
406 }
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
407
31141
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
408 static void dummy_sighandler(int x) {
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
409 }
33617
c77bf171b354 cache2: Surround conditionally used functions by appropriate #ifdefs.
diego
parents: 33517
diff changeset
410 #endif
31141
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
411
30360
c74a5f8ffab3 Change code to allow playing a stream even if enabling the cache failed
reimar
parents: 30359
diff changeset
412 /**
31144
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
413 * Main loop of the cache process or thread.
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
414 */
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
415 static void cache_mainloop(cache_vars_t *s) {
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
416 int sleep_count = 0;
31189
edfa98275e04 Fix cache process accidentally being killed by SIGUSR1.
reimar
parents: 31181
diff changeset
417 #if FORKED_CACHE
33835
8d3d721a0532 cache2: merge struct declaration and member assignment
diego
parents: 33823
diff changeset
418 struct sigaction sa = { .sa_handler = SIG_IGN };
31672
61eac0d05f20 Use sigaction() instead of signal(), the latter has a unavoidable
reimar
parents: 31311
diff changeset
419 sigaction(SIGUSR1, &sa, NULL);
31189
edfa98275e04 Fix cache process accidentally being killed by SIGUSR1.
reimar
parents: 31181
diff changeset
420 #endif
31144
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
421 do {
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
422 if (!cache_fill(s)) {
31167
09e3134b649d Re-enable wakeup-on-signal for cache process.
reimar
parents: 31166
diff changeset
423 #if FORKED_CACHE
09e3134b649d Re-enable wakeup-on-signal for cache process.
reimar
parents: 31166
diff changeset
424 // Let signal wake us up, we cannot leave this
09e3134b649d Re-enable wakeup-on-signal for cache process.
reimar
parents: 31166
diff changeset
425 // enabled since we do not handle EINTR in most places.
09e3134b649d Re-enable wakeup-on-signal for cache process.
reimar
parents: 31166
diff changeset
426 // This might need extra code to work on BSD.
31672
61eac0d05f20 Use sigaction() instead of signal(), the latter has a unavoidable
reimar
parents: 31311
diff changeset
427 sa.sa_handler = dummy_sighandler;
61eac0d05f20 Use sigaction() instead of signal(), the latter has a unavoidable
reimar
parents: 31311
diff changeset
428 sigaction(SIGUSR1, &sa, NULL);
31167
09e3134b649d Re-enable wakeup-on-signal for cache process.
reimar
parents: 31166
diff changeset
429 #endif
31144
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
430 if (sleep_count < INITIAL_FILL_USLEEP_COUNT) {
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
431 sleep_count++;
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
432 usec_sleep(INITIAL_FILL_USLEEP_TIME);
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
433 } else
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
434 usec_sleep(FILL_USLEEP_TIME); // idle
31167
09e3134b649d Re-enable wakeup-on-signal for cache process.
reimar
parents: 31166
diff changeset
435 #if FORKED_CACHE
31672
61eac0d05f20 Use sigaction() instead of signal(), the latter has a unavoidable
reimar
parents: 31311
diff changeset
436 sa.sa_handler = SIG_IGN;
61eac0d05f20 Use sigaction() instead of signal(), the latter has a unavoidable
reimar
parents: 31311
diff changeset
437 sigaction(SIGUSR1, &sa, NULL);
31167
09e3134b649d Re-enable wakeup-on-signal for cache process.
reimar
parents: 31166
diff changeset
438 #endif
31144
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
439 } else
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
440 sleep_count = 0;
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
441 } while (cache_execute_control(s));
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
442 }
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
443
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
444 /**
30360
c74a5f8ffab3 Change code to allow playing a stream even if enabling the cache failed
reimar
parents: 30359
diff changeset
445 * \return 1 on success, 0 if the function was interrupted and -1 on error
c74a5f8ffab3 Change code to allow playing a stream even if enabling the cache failed
reimar
parents: 30359
diff changeset
446 */
16152
10a69a812eff remove unused cache-prefill and create cache-seek-min that controls when seek_long is prefered over waiting for cache to fill
iive
parents: 12899
diff changeset
447 int stream_enable_cache(stream_t *stream,int size,int min,int seek_limit){
25445
959fca775f43 Fix stream_cache to use sector_size set in stream_t.
ulion
parents: 24697
diff changeset
448 int ss = stream->sector_size ? stream->sector_size : STREAM_BUFFER_SIZE;
30362
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
449 int res = -1;
5991
ddfae38afc28 cache lower limit 32kb
arpi
parents: 5931
diff changeset
450 cache_vars_t* s;
7006
c0b490505298 disable cache if stream->fd<0 (no regular file/pipe but some special thing)
arpi
parents: 5991
diff changeset
451
29888
5c39c41f38e8 Deobfuscate the special hack to disable cache for live555.
reimar
parents: 29263
diff changeset
452 if (stream->flags & STREAM_NON_CACHEABLE) {
7204
eee464fa02c1 fix cache disable for live.com
atmos4
parents: 7202
diff changeset
453 mp_msg(MSGT_CACHE,MSGL_STATUS,"\rThis stream is non-cacheable\n");
eee464fa02c1 fix cache disable for live.com
atmos4
parents: 7202
diff changeset
454 return 1;
eee464fa02c1 fix cache disable for live.com
atmos4
parents: 7202
diff changeset
455 }
7006
c0b490505298 disable cache if stream->fd<0 (no regular file/pipe but some special thing)
arpi
parents: 5991
diff changeset
456
5991
ddfae38afc28 cache lower limit 32kb
arpi
parents: 5931
diff changeset
457 s=cache_init(size,ss);
30360
c74a5f8ffab3 Change code to allow playing a stream even if enabling the cache failed
reimar
parents: 30359
diff changeset
458 if(s == NULL) return -1;
3562
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
459 stream->cache_data=s;
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
460 s->stream=stream; // callback
16152
10a69a812eff remove unused cache-prefill and create cache-seek-min that controls when seek_long is prefered over waiting for cache to fill
iive
parents: 12899
diff changeset
461 s->seek_limit=seek_limit;
12835
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
462
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
463
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
464 //make sure that we won't wait from cache_fill
31181
e735964b5d56 Fix a bunch of typos in the stream cache code.
diego
parents: 31169
diff changeset
465 //more data than it is allowed to fill
16152
10a69a812eff remove unused cache-prefill and create cache-seek-min that controls when seek_long is prefered over waiting for cache to fill
iive
parents: 12899
diff changeset
466 if (s->seek_limit > s->buffer_size - s->fill_limit ){
10a69a812eff remove unused cache-prefill and create cache-seek-min that controls when seek_long is prefered over waiting for cache to fill
iive
parents: 12899
diff changeset
467 s->seek_limit = s->buffer_size - s->fill_limit;
12835
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
468 }
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
469 if (min > s->buffer_size - s->fill_limit) {
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
470 min = s->buffer_size - s->fill_limit;
4235ae5a2d60 cache min fill adjustment, based on patch by Jeremy Huddleston
iive
parents: 10272
diff changeset
471 }
31189
edfa98275e04 Fix cache process accidentally being killed by SIGUSR1.
reimar
parents: 31181
diff changeset
472 // to make sure we wait for the cache process/thread to be active
edfa98275e04 Fix cache process accidentally being killed by SIGUSR1.
reimar
parents: 31181
diff changeset
473 // before continuing
edfa98275e04 Fix cache process accidentally being killed by SIGUSR1.
reimar
parents: 31181
diff changeset
474 if (min <= 0)
edfa98275e04 Fix cache process accidentally being killed by SIGUSR1.
reimar
parents: 31181
diff changeset
475 min = 1;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
476
31146
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
477 #if FORKED_CACHE
3562
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
478 if((stream->cache_pid=fork())){
30351
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
479 if ((pid_t)stream->cache_pid == -1)
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
480 stream->cache_pid = 0;
10197
9e11a478a3bc use threads on windows
faust3
parents: 9915
diff changeset
481 #else
9e11a478a3bc use threads on windows
faust3
parents: 9915
diff changeset
482 {
9e11a478a3bc use threads on windows
faust3
parents: 9915
diff changeset
483 stream_t* stream2=malloc(sizeof(stream_t));
9e11a478a3bc use threads on windows
faust3
parents: 9915
diff changeset
484 memcpy(stream2,s->stream,sizeof(stream_t));
9e11a478a3bc use threads on windows
faust3
parents: 9915
diff changeset
485 s->stream=stream2;
27894
d06d8e459ae1 Use pthreads for the cache on Cygwin, since _beginthread is not available
reimar
parents: 27876
diff changeset
486 #if defined(__MINGW32__)
27770
c8d4cace053d Avoid CreateThread and especially TerminateThread since they cause a memleak.
reimar
parents: 27769
diff changeset
487 stream->cache_pid = _beginthread( ThreadProc, 0, s );
27894
d06d8e459ae1 Use pthreads for the cache on Cygwin, since _beginthread is not available
reimar
parents: 27876
diff changeset
488 #elif defined(__OS2__)
d06d8e459ae1 Use pthreads for the cache on Cygwin, since _beginthread is not available
reimar
parents: 27876
diff changeset
489 stream->cache_pid = _beginthread( ThreadProc, NULL, 256 * 1024, s );
27770
c8d4cace053d Avoid CreateThread and especially TerminateThread since they cause a memleak.
reimar
parents: 27769
diff changeset
490 #else
27896
4c2232462353 100l, stream->cache_pid can not be used directly in pthread_create,
reimar
parents: 27894
diff changeset
491 {
4c2232462353 100l, stream->cache_pid can not be used directly in pthread_create,
reimar
parents: 27894
diff changeset
492 pthread_t tid;
4c2232462353 100l, stream->cache_pid can not be used directly in pthread_create,
reimar
parents: 27894
diff changeset
493 pthread_create(&tid, NULL, ThreadProc, s);
4c2232462353 100l, stream->cache_pid can not be used directly in pthread_create,
reimar
parents: 27894
diff changeset
494 stream->cache_pid = 1;
4c2232462353 100l, stream->cache_pid can not be used directly in pthread_create,
reimar
parents: 27894
diff changeset
495 }
26077
d8128689c031 cache support for OS/2
diego
parents: 25445
diff changeset
496 #endif
10197
9e11a478a3bc use threads on windows
faust3
parents: 9915
diff changeset
497 #endif
30351
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
498 if (!stream->cache_pid) {
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
499 mp_msg(MSGT_CACHE, MSGL_ERR,
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
500 "Starting cache process/thread failed: %s.\n", strerror(errno));
30362
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
501 goto err_out;
30351
b985db55e78a Check for fork failing and make sure cache_uninit always frees the cache data
reimar
parents: 29888
diff changeset
502 }
3562
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
503 // wait until cache is filled at least prefill_init %
17366
934380353fd6 massive attack: mp_msg printf format fixes
rathann
parents: 17012
diff changeset
504 mp_msg(MSGT_CACHE,MSGL_V,"CACHE_PRE_INIT: %"PRId64" [%"PRId64"] %"PRId64" pre:%d eof:%d \n",
17384
95d02479f1d6 1l - one cast too many
rathann
parents: 17366
diff changeset
505 (int64_t)s->min_filepos,(int64_t)s->read_filepos,(int64_t)s->max_filepos,min,s->eof);
3562
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
506 while(s->read_filepos<s->min_filepos || s->max_filepos-s->read_filepos<min){
16793
8d4fb5469efb Make a few more messages translatable by moving them into help_mp-en.h.
diego
parents: 16750
diff changeset
507 mp_msg(MSGT_CACHE,MSGL_STATUS,MSGTR_CacheFill,
3600
3094e7b6a15b pre-cache fixed
arpi
parents: 3562
diff changeset
508 100.0*(float)(s->max_filepos-s->read_filepos)/(float)(s->buffer_size),
17366
934380353fd6 massive attack: mp_msg printf format fixes
rathann
parents: 17012
diff changeset
509 (int64_t)s->max_filepos-s->read_filepos
3562
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
510 );
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
511 if(s->eof) break; // file is smaller than prefill size
30362
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
512 if(stream_check_interrupt(PREFILL_SLEEP_TIME)) {
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
513 res = 0;
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
514 goto err_out;
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
515 }
3562
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
516 }
16870
09ad0b5e6643 add a \n after whole cache fill.
ods15
parents: 16793
diff changeset
517 mp_msg(MSGT_CACHE,MSGL_STATUS,"\n");
4825
41d2da3bd082 Make blocking call in libmpdemux interuptable (only with new input,
albeu
parents: 3726
diff changeset
518 return 1; // parent exits
30362
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
519
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
520 err_out:
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
521 cache_uninit(stream);
48c51ebbe421 Always call cache_uninit to immediately free everything cache-related if we
reimar
parents: 30360
diff changeset
522 return res;
3562
e84d6c8ff59b initial precaching
arpi
parents: 2374
diff changeset
523 }
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
524
31146
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
525 #if FORKED_CACHE
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
526 signal(SIGTERM,exit_sighandler); // kill
31144
c2d5a1f6360b Extract the cache main loop into a separate function.
reimar
parents: 31142
diff changeset
527 cache_mainloop(s);
30355
ca3e3df28fe2 Add an exit() to silence a gcc warning and ensure forked code will never
reimar
parents: 30354
diff changeset
528 // make sure forked code never leaves this function
ca3e3df28fe2 Add an exit() to silence a gcc warning and ensure forked code will never
reimar
parents: 30354
diff changeset
529 exit(0);
30712
75903ab49159 Restructure #ifs to be clearer, also ensures that we return from the thread
reimar
parents: 30691
diff changeset
530 #endif
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
531 }
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
532
31146
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
533 #if !FORKED_CACHE
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
534 #if defined(__MINGW32__) || defined(__OS2__)
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
535 static void ThreadProc( void *s ){
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
536 cache_mainloop(s);
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
537 _endthread();
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
538 }
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
539 #else
31145
47d2e52f61b4 Try reducing the #ifdef mess for the different cache variants.
reimar
parents: 31144
diff changeset
540 static void *ThreadProc( void *s ){
47d2e52f61b4 Try reducing the #ifdef mess for the different cache variants.
reimar
parents: 31144
diff changeset
541 cache_mainloop(s);
47d2e52f61b4 Try reducing the #ifdef mess for the different cache variants.
reimar
parents: 31144
diff changeset
542 return NULL;
47d2e52f61b4 Try reducing the #ifdef mess for the different cache variants.
reimar
parents: 31144
diff changeset
543 }
31146
78d11e186bfc Use an extra define to simplify ifdefs
reimar
parents: 31145
diff changeset
544 #endif
31145
47d2e52f61b4 Try reducing the #ifdef mess for the different cache variants.
reimar
parents: 31144
diff changeset
545 #endif
47d2e52f61b4 Try reducing the #ifdef mess for the different cache variants.
reimar
parents: 31144
diff changeset
546
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
547 int cache_stream_fill_buffer(stream_t *s){
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
548 int len;
31835
73f85fc599e0 Add sanity-check for sector size to avoid strange crashes if it is
reimar
parents: 31828
diff changeset
549 int sector_size;
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
550 if(!s->cache_pid) return stream_fill_buffer(s);
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
551
2371
0f2cad867121 printf->mp_msg
arpi
parents: 2352
diff changeset
552 if(s->pos!=((cache_vars_t*)s->cache_data)->read_filepos) mp_msg(MSGT_CACHE,MSGL_ERR,"!!! read_filepos differs!!! report this bug...\n");
31835
73f85fc599e0 Add sanity-check for sector size to avoid strange crashes if it is
reimar
parents: 31828
diff changeset
553 sector_size = ((cache_vars_t*)s->cache_data)->sector_size;
73f85fc599e0 Add sanity-check for sector size to avoid strange crashes if it is
reimar
parents: 31828
diff changeset
554 if (sector_size > STREAM_MAX_SECTOR_SIZE) {
73f85fc599e0 Add sanity-check for sector size to avoid strange crashes if it is
reimar
parents: 31828
diff changeset
555 mp_msg(MSGT_CACHE, MSGL_ERR, "Sector size %i larger than maximum %i\n", sector_size, STREAM_MAX_SECTOR_SIZE);
73f85fc599e0 Add sanity-check for sector size to avoid strange crashes if it is
reimar
parents: 31828
diff changeset
556 sector_size = STREAM_MAX_SECTOR_SIZE;
73f85fc599e0 Add sanity-check for sector size to avoid strange crashes if it is
reimar
parents: 31828
diff changeset
557 }
2327
2332ba356d03 print stats at read instead of fill
arpi
parents: 2324
diff changeset
558
31835
73f85fc599e0 Add sanity-check for sector size to avoid strange crashes if it is
reimar
parents: 31828
diff changeset
559 len=cache_read(s->cache_data,s->buffer, sector_size);
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
560 //printf("cache_stream_fill_buffer->read -> %d\n",len);
2327
2332ba356d03 print stats at read instead of fill
arpi
parents: 2324
diff changeset
561
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
562 if(len<=0){ s->eof=1; s->buf_pos=s->buf_len=0; return 0; }
31169
ac84149bbdaf Retry reading even if we hit eof before.
reimar
parents: 31167
diff changeset
563 s->eof=0;
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
564 s->buf_pos=0;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
565 s->buf_len=len;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
566 s->pos+=len;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
567 // printf("[%d]",len);fflush(stdout);
32438
faefba58f413 Implement a basic capture feature, available through -capture.
diego
parents: 32037
diff changeset
568 if (s->capture_file)
faefba58f413 Implement a basic capture feature, available through -capture.
diego
parents: 32037
diff changeset
569 stream_capture_do(s);
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
570 return len;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
571
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
572 }
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
573
32731
005b026b1231 Convert cache_fill_status into a function so we always get the latest state,
reimar
parents: 32728
diff changeset
574 int cache_fill_status(stream_t *s) {
005b026b1231 Convert cache_fill_status into a function so we always get the latest state,
reimar
parents: 32728
diff changeset
575 cache_vars_t *cv;
005b026b1231 Convert cache_fill_status into a function so we always get the latest state,
reimar
parents: 32728
diff changeset
576 if (!s || !s->cache_data)
005b026b1231 Convert cache_fill_status into a function so we always get the latest state,
reimar
parents: 32728
diff changeset
577 return -1;
005b026b1231 Convert cache_fill_status into a function so we always get the latest state,
reimar
parents: 32728
diff changeset
578 cv = s->cache_data;
005b026b1231 Convert cache_fill_status into a function so we always get the latest state,
reimar
parents: 32728
diff changeset
579 return (cv->max_filepos-cv->read_filepos)/(cv->buffer_size / 100);
005b026b1231 Convert cache_fill_status into a function so we always get the latest state,
reimar
parents: 32728
diff changeset
580 }
005b026b1231 Convert cache_fill_status into a function so we always get the latest state,
reimar
parents: 32728
diff changeset
581
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
582 int cache_stream_seek_long(stream_t *stream,off_t pos){
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
583 cache_vars_t* s;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
584 off_t newpos;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
585 if(!stream->cache_pid) return stream_seek_long(stream,pos);
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
586
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
587 s=stream->cache_data;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
588 // s->seek_lock=1;
29263
0f1b5b68af32 whitespace cosmetics: Remove all trailing whitespace.
diego
parents: 28014
diff changeset
589
17366
934380353fd6 massive attack: mp_msg printf format fixes
rathann
parents: 17012
diff changeset
590 mp_msg(MSGT_CACHE,MSGL_DBG2,"CACHE2_SEEK: 0x%"PRIX64" <= 0x%"PRIX64" (0x%"PRIX64") <= 0x%"PRIX64" \n",s->min_filepos,pos,s->read_filepos,s->max_filepos);
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
591
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
592 newpos=pos/s->sector_size; newpos*=s->sector_size; // align
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
593 stream->pos=s->read_filepos=newpos;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
594 s->eof=0; // !!!!!!!
31141
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
595 cache_wakeup(stream);
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
596
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
597 cache_stream_fill_buffer(stream);
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
598
2352
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
599 pos-=newpos;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
600 if(pos>=0 && pos<=stream->buf_len){
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
601 stream->buf_pos=pos; // byte position in sector
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
602 return 1;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
603 }
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
604
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
605 // stream->buf_pos=stream->buf_len=0;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
606 // return 1;
3b22db95aaf6 cache seeking fixed(?)
arpi
parents: 2348
diff changeset
607
16750
0a31740dd5e6 Use PRI?64 defines as format strings for 64 bit variables.
reimar
parents: 16152
diff changeset
608 mp_msg(MSGT_CACHE,MSGL_V,"cache_stream_seek: WARNING! Can't seek to 0x%"PRIX64" !\n",(int64_t)(pos+newpos));
2322
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
609 return 0;
e22ec6fce385 cache2 support
arpi
parents:
diff changeset
610 }
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
611
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
612 int cache_do_control(stream_t *stream, int cmd, void *arg) {
31190
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
613 int sleep_count = 0;
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
614 int pos_change = 0;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
615 cache_vars_t* s = stream->cache_data;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
616 switch (cmd) {
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
617 case STREAM_CTRL_SEEK_TO_TIME:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
618 s->control_double_arg = *(double *)arg;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
619 s->control = cmd;
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
620 pos_change = 1;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
621 break;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
622 case STREAM_CTRL_SEEK_TO_CHAPTER:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
623 case STREAM_CTRL_SET_ANGLE:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
624 s->control_uint_arg = *(unsigned *)arg;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
625 s->control = cmd;
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
626 pos_change = 1;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
627 break;
33517
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
628 // the core might call these every frame, so cache them...
26847
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
629 case STREAM_CTRL_GET_TIME_LENGTH:
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
630 *(double *)arg = s->stream_time_length;
4f875ae5d538 Emulate STREAM_CTRL_GET_TIME_LENGTH if cache is used.
reimar
parents: 26833
diff changeset
631 return s->stream_time_length ? STREAM_OK : STREAM_UNSUPPORTED;
33517
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
632 case STREAM_CTRL_GET_CURRENT_TIME:
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
633 *(double *)arg = s->stream_time_pos;
850a3272e10d Change code to allow STREAM_CTRL_GET_CURRENT_TIME with cache enabled.
reimar
parents: 33512
diff changeset
634 return s->stream_time_pos != MP_NOPTS_VALUE ? STREAM_OK : STREAM_UNSUPPORTED;
34648
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
635 case STREAM_CTRL_GET_LANG:
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
636 s->control_lang_arg = *(struct stream_lang_req *)arg;
26924
ca50c4a72f68 100l, fix wrong order of cases in cache_do_control
reimar
parents: 26897
diff changeset
637 case STREAM_CTRL_GET_NUM_CHAPTERS:
ca50c4a72f68 100l, fix wrong order of cases in cache_do_control
reimar
parents: 26897
diff changeset
638 case STREAM_CTRL_GET_CURRENT_CHAPTER:
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
639 case STREAM_CTRL_GET_ASPECT_RATIO:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
640 case STREAM_CTRL_GET_NUM_ANGLES:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
641 case STREAM_CTRL_GET_ANGLE:
27770
c8d4cace053d Avoid CreateThread and especially TerminateThread since they cause a memleak.
reimar
parents: 27769
diff changeset
642 case -2:
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
643 s->control = cmd;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
644 break;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
645 default:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
646 return STREAM_UNSUPPORTED;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
647 }
31141
3b5e8cc5e128 Add code to wake up cache process when e.g. a seek is needed.
reimar
parents: 30731
diff changeset
648 cache_wakeup(stream);
31190
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
649 while (s->control != -1) {
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
650 if (sleep_count++ == 1000)
33867
76b818cbb359 Mark two warnings that usually only indicate a performance issue as such.
reimar
parents: 33835
diff changeset
651 mp_msg(MSGT_CACHE, MSGL_WARN, "Cache not responding! [performance issue]\n");
31190
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
652 if (stream_check_interrupt(CONTROL_SLEEP_TIME)) {
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
653 s->eof = 1;
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
654 return STREAM_UNSUPPORTED;
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
655 }
8432358f2d32 Improve handling of cache process/thread hanging/being killed.
reimar
parents: 31189
diff changeset
656 }
34487
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
657 if (s->control_res != STREAM_OK)
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
658 return s->control_res;
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
659 // We cannot do this on failure, since this would cause the
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
660 // stream position to jump when e.g. STREAM_CTRL_SEEK_TO_TIME
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
661 // is unsupported - but in that case we need the old value
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
662 // to do the fallback seek.
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
663 // This unfortunately can lead to slightly different behaviour
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
664 // with and without cache if the protocol changes pos even
ebf95780af6e Fix seeking with e.g. flv files.
reimar
parents: 34373
diff changeset
665 // when an error happened.
34373
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
666 if (pos_change) {
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
667 stream->pos = s->read_filepos;
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
668 stream->eof = s->eof;
7a4dbec9415b Flush cache and sync stream position/eof after seeking STREAM_CTRLs.
reimar
parents: 34283
diff changeset
669 }
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
670 switch (cmd) {
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
671 case STREAM_CTRL_GET_TIME_LENGTH:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
672 case STREAM_CTRL_GET_CURRENT_TIME:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
673 case STREAM_CTRL_GET_ASPECT_RATIO:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
674 *(double *)arg = s->control_double_arg;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
675 break;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
676 case STREAM_CTRL_GET_NUM_CHAPTERS:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
677 case STREAM_CTRL_GET_CURRENT_CHAPTER:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
678 case STREAM_CTRL_GET_NUM_ANGLES:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
679 case STREAM_CTRL_GET_ANGLE:
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
680 *(unsigned *)arg = s->control_uint_arg;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
681 break;
34648
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
682 case STREAM_CTRL_GET_LANG:
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
683 *(struct stream_lang_req *)arg = s->control_lang_arg;
26eddbd6353a Code cleanup: Use a stream_control instead of global functions to
reimar
parents: 34488
diff changeset
684 break;
26833
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
685 }
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
686 return s->control_res;
77003eb2d9a8 Add basic support for stream controls with cache enabled.
reimar
parents: 26326
diff changeset
687 }