]> git.vomp.tv Git - vompclient.git/blob - imagereader.cc
Control/main/winmain/util reorg
[vompclient.git] / imagereader.cc
1 /*
2     Copyright 2004-2006 Chris Tallon, Andreas Vogel
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP; if not, write to the Free Software
18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19 */
20
21 #include "imagereader.h"
22 #include "mediaprovider.h"
23 #include "media.h"
24 #include "i18n.h"
25 #include "log.h"
26
27
28 ImageReader::ImageReader(int c, MediaProvider *p) 
29 {
30   logger = Log::getInstance();
31   logger->log("ImageReader", Log::DEBUG, "ctorI");
32   provider=p;
33   channel=c;
34   running=false;
35   readerRunning=false;
36   this->run();
37 }
38
39 ImageReader::~ImageReader()
40 {
41   if (readerRunning) shutdown();
42   for (int i=0;i<MAXCHUNKS;i++) {
43     if (data[i].buffer != NULL) free(data[i].buffer);
44     data[i].buffer=NULL;
45   }
46 }
47
48
49 void ImageReader::run() {
50   if (running) return;
51   running=true;
52   readerRunning=true;
53   threadStart();
54 }
55
56
57 void ImageReader::shutdown()
58 {
59   running=false;
60   if (readerRunning) {
61     logger->log("ImageReader",Log::DEBUG,"shutdown - warting for reader thread to stop");
62     threadSignalNoLock();
63     logger->log("ImageReader",Log::DEBUG,"shutdown notified");
64     //wait for the reader thread to stop
65     //at most wait 10s
66     for (int loopcount=200;readerRunning && loopcount > 0;loopcount--) {
67       MILLISLEEP(50);
68     }
69     if (readerRunning) {
70       logger->log("ImageReader",Log::ERR,"shutdown - unable to stop reader within 10s");
71     }
72   }
73 }
74
75 void ImageReader::stop() {
76   if (readerRunning) {
77     threadLock();
78     int numopen=0;
79     for (int i=0; i< MAXCHUNKS;i++) {
80       if (data[i].state == S_FETCHING) {
81         data[i].state = S_BREAK;
82         numopen++;
83       }
84     }
85     threadUnlock();
86     int loopcount=200;
87     while (numopen > 0 && loopcount > 0) {
88       numopen=0;
89       logger->log("ImageReader",Log::DEBUG,"stop - warting for reader thread to stop");
90       threadSignalNoLock();
91       logger->log("ImageReader",Log::DEBUG,"stop notified");
92       MILLISLEEP(50);
93       threadLock();
94       for (int i=0; i< MAXCHUNKS;i++) {
95         if (data[i].state == S_FETCHING) {
96           data[i].state = S_BREAK;
97           numopen++;
98         }
99       }
100       threadUnlock();
101       loopcount--;
102     }
103     if (numopen > 0) 
104       logger->log("ImageReader",Log::ERR,"stop - unable to stop reader thread");
105   }
106 }
107
108
109
110 bool ImageReader::isReaderRunning() {
111   return readerRunning;
112 }
113
114
115
116 // ----------------------------------- Feed thread
117
118 void ImageReader::waitTimed(int ms) {
119   threadLock();
120   struct timespec nt;
121   int sec=ms/1000;
122   int us=1000*(ms - 1000*sec);
123 #ifndef WIN32
124   struct timeval ct;
125   gettimeofday(&ct,NULL);
126   nt.tv_sec=ct.tv_sec+sec;
127   nt.tv_nsec=1000*us+1000*ct.tv_usec;
128 #else 
129     DWORD ct=timeGetTime();
130     nt.tv_sec=ct/1000+sec;
131     nt.tv_nsec=1000*us+1000*ct*1000;
132 #endif
133   threadWaitForSignalTimed(&nt);
134   threadUnlock();
135 }
136
137 void ImageReader::threadMethod()
138 {
139   logger->log("ImageReader", Log::DEBUG, "player thread started");
140   int currentChunk=-1;
141   while(1)
142   {
143     if (! running) {
144       break;
145     }
146     if (currentChunk < 0) {
147       threadLock();
148       //check if new request is there (used=true && ongoing=true)
149       for (int i=0; i< MAXCHUNKS; i++) {
150         if (data[i].state == S_REQUEST) {
151           //found new chunk request
152           logger->log("ImageReaderThread", Log::DEBUG, "new chunk request found %i, offset=%llu, len=%u",i,data[i].offset,data[i].reqlen);
153           currentChunk=i;
154           data[i].state=S_FETCHING;
155           break;
156           }
157         }
158       threadUnlock();
159     }
160     threadCheckExit();
161     if (currentChunk < 0) {
162       waitTimed(500);
163       continue;
164     }
165     data[currentChunk].len=0;
166     logger->log("ImageReaderThread", Log::DEBUG, "start receive, offset %llu, len %u",data[currentChunk].offset,data[currentChunk].reqlen);
167     data[currentChunk].buffer=NULL;
168     int rt= provider->getMediaBlock(channel,data[currentChunk].offset, data[currentChunk].reqlen , &(data[currentChunk].len),&(data[currentChunk].buffer));
169     //set the chunk to ready
170     logger->log("ImageReaderThread", Log::DEBUG, "chunk received, offset %llu, len %u",data[currentChunk].offset,data[currentChunk].len);
171     if (rt != 0 || !(data[currentChunk].buffer) || data[currentChunk].len == 0 ) {
172         //OK we count this as end of stream
173         logger->log("ImageReaderThread", Log::DEBUG, "stream end");
174         if (data[currentChunk].buffer != NULL) {
175           free(data[currentChunk].buffer);
176           data[currentChunk].buffer=NULL;
177         }
178       }
179     threadLock();
180     //OK - now the chunk is received, try to see if we can read the next
181     //if somebody told us that this chunk is not needed any more we clean up
182     if ( data[currentChunk].state == S_BREAK) {
183       logger->log("ImageReaderThread", Log::DEBUG, "throw away chunk offset %llu, len %u", data[currentChunk].offset,data[currentChunk].reqlen);
184       data[currentChunk].len=0;
185       if (data[currentChunk].buffer) free(data[currentChunk].buffer);
186       data[currentChunk].buffer=NULL;
187       data[currentChunk].state=S_FREE;
188     }
189     data[currentChunk].state=S_READY;
190     if (data[currentChunk].len > 0) {
191       int i=0;
192       for (; i< MAXCHUNKS;i++) {
193         if (data[i].state == S_FREE ) {
194           data[i].state=S_REQUEST;
195           data[i].buffer=NULL;
196           data[i].offset=data[currentChunk].offset+data[currentChunk].len;
197           data[i].reqlen=data[currentChunk].reqlen;
198           logger->log("ImageReaderThread", Log::DEBUG, "follow on for offset %llu, len %u", data[i].offset,data[i].reqlen);
199           break;
200           }
201         }
202         //if we have a free chunk - read the data
203         if (i < MAXCHUNKS) currentChunk=i;
204         else currentChunk=-1;
205       } 
206     else {
207       //OEF or error - don't read next chunk
208       currentChunk=-1;
209       }
210     threadUnlock();
211     threadSignalNoLock();
212     }
213   logger->log("ImageReaderThread", Log::DEBUG, "finished");
214   readerRunning=false;
215   return;
216 }
217
218 void ImageReader::call(void *) {
219   threadSignalNoLock();
220 }
221  
222 // the real entry for receiving data
223 int ImageReader::getImageChunk(ULLONG  offset,UINT len, UINT * rsize, UCHAR **buffer){
224   logger->log("ImageReader", Log::DEBUG, "request chunk offset=%llu, len=%u",offset,len);
225   threadLock();
226   *buffer=NULL;
227   *rsize=0;
228   for (int found=2;found> 0; found--) {
229     //currently simple - we only check if we really have a chunk with exactly matching start
230     for (int i=0; i< MAXCHUNKS; i++ ) {
231       if (data[i].state != S_FREE && data[i].offset == offset) {
232         found=0;
233         while ( data[i].state != S_READY && data[i].state != S_FREE && readerRunning) {
234             threadUnlock();
235             waitTimed(500);
236             threadLock();
237             }
238         if (data[i].state == S_READY) {
239           //data is available
240           *buffer=data[i].buffer;
241           *rsize=data[i].len;
242           //now free the entry
243           data[i].buffer=NULL;
244           data[i].state=S_FREE;
245           logger->log("ImageReader", Log::DEBUG, "ready chunk found at index %u,offset=%llu, len=%u",i,data[i].offset,data[i].len);
246           if ( data[i].len >0) {
247             //check if the next chunk is already on the way
248             ULLONG nexto=data[i].offset+data[i].len;
249             bool nfound=false;
250             for (int x=0;x<MAXCHUNKS;x++) {
251               if (data[x].state != S_FREE && data[x].state != S_BREAK && data[x].offset==nexto) {
252                 nfound=true;
253                 break;
254               }
255             }
256             if (! nfound) {
257               //set up request for next chunk
258               data[i].offset=nexto;
259               data[i].state=S_REQUEST;
260               logger->log("ImageReader", Log::DEBUG, "next chunk requested at index %u,offset=%llu, len=%u",i,data[i].offset,data[i].reqlen);
261             }
262           }
263           break;
264           }
265         else {
266           //thread seems to be stopped
267           logger->log("ImageReader", Log::DEBUG, "no ready chunk found although in list");
268           ;
269           }
270         break;
271         }
272       }
273     if (found == 0) {
274       threadUnlock();
275       logger->log("ImageReader", Log::DEBUG, "returning buffer 0x%p, len %u",*buffer,*rsize);
276       threadSignalNoLock();
277       return 0;
278       }
279     //we found no chunk for us - so set up a new one
280     //remove all chunks 
281     for (int i=0;i<MAXCHUNKS;i++) {
282       if (data[i].state == S_FETCHING) {
283         //the reader is just fetching - let him finish
284         data[i].state = S_BREAK;
285         }
286       else {
287         data[i].state=S_FREE;
288         if (data[i].buffer) free(data[i].buffer);
289         data[i].buffer=NULL;
290       }
291     }
292     //now we should find one free anyway
293     bool ffree=false;
294     for (int i=0;i<MAXCHUNKS;i++) {
295       if (data[i].state==S_FREE) {
296         ffree=true;
297         data[i].offset=offset;
298         data[i].reqlen=len;
299         data[i].state=S_REQUEST;
300         threadSignalNoLock();
301         break;
302         }
303       }
304     if (! ffree) {
305       logger->log("ImageReader", Log::ERR, "no free chunk to load data");
306       threadUnlock();
307       return -1;
308       }
309     }
310   threadUnlock();
311   logger->log("ImageReader", Log::ERR, "unable to get data");
312   return -1;
313   }
314         
315     
316   
317
318