?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix the last warning
[kugel-rb.git] / apps / plugins / video.c
blob2799e3d5d1b99f2a5b2c2a647d8bc20da2978787
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Plugin for video playback
11 * Reads raw image data + audio data from a file
12 * !!!!!!!!!! Code Police free zone !!!!!!!!!!
13 *
14 * Copyright (C) 2003-2004 J�g Hohensohn aka [IDC]Dragon
15 *
16 * All files in this archive are subject to the GNU General Public License.
17 * See the file COPYING in the source tree root for full license agreement.
18 *
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
21 *
22 ****************************************************************************/
23
24
25 /****************** imports ******************/
26
27 #include "plugin.h"
28 #include "sh7034.h"
29 #include "system.h"
30 #include "helper.h"
31
32 #ifndef SIMULATOR /* not for simulator by now */
33 #ifdef HAVE_LCD_BITMAP /* and definitely not for the Player, haha */
34
35 PLUGIN_HEADER
36
37 /* variable button definitions */
38 #if CONFIG_KEYPAD == RECORDER_PAD
39 #define VIDEO_STOP_SEEK BUTTON_PLAY
40 #define VIDEO_RESUME BUTTON_PLAY
41 #define VIDEO_DEBUG BUTTON_F1
42 #define VIDEO_CONTRAST_DOWN BUTTON_F2
43 #define VIDEO_CONTRAST_UP BUTTON_F3
44
45 #elif CONFIG_KEYPAD == ONDIO_PAD
46 #define VIDEO_STOP_SEEK_PRE BUTTON_MENU
47 #define VIDEO_STOP_SEEK (BUTTON_MENU | BUTTON_REL)
48 #define VIDEO_RESUME BUTTON_RIGHT
49 #define VIDEO_CONTRAST_DOWN (BUTTON_MENU | BUTTON_DOWN)
50 #define VIDEO_CONTRAST_UP (BUTTON_MENU | BUTTON_UP)
51
52 #endif
53 /****************** constants ******************/
54
55 #define SCREENSIZE (LCD_WIDTH*LCD_HEIGHT/8) /* in bytes */
56 #define FPS 68 /* default fps for headerless (old video-only) file */
57 #define MAX_ACC 20 /* maximum FF/FR speedup */
58 #define FF_TICKS 3000; /* experimentally found nice */
59
60 /* trigger levels, we need about 80 kB/sec */
61 #define SPINUP_INIT 5000 /* from what level on to refill, in milliseconds */
62 #define SPINUP_SAFETY 700 /* how much on top of the measured spinup time */
63 #define CHUNK (1024*32) /* read size */
64
65
66 /****************** prototypes ******************/
67 void timer4_isr(void); /* IMIA4 ISR */
68 int check_button(void); /* determine next relative frame */
69
70
71 /****************** data types ******************/
72
73 /* plugins don't introduce headers, so structs are repeated from rvf_format.h */
74
75 #define HEADER_MAGIC 0x52564668 /* "RVFh" at file start */
76 #define AUDIO_MAGIC 0x41756446 /* "AudF" for each audio block */
77 #define FILEVERSION 100 /* 1.00 */
78
79 /* format type definitions */
80 #define VIDEOFORMAT_NO_VIDEO 0
81 #define VIDEOFORMAT_RAW 1
82 #define AUDIOFORMAT_NO_AUDIO 0
83 #define AUDIOFORMAT_MP3 1
84 #define AUDIOFORMAT_MP3_BITSWAPPED 2
85
86 /* bit flags */
87 #define FLAG_LOOP 0x00000001 /* loop the playback, e.g. for stills */
88
89 typedef struct /* contains whatever might be useful to the player */
90 {
91 /* general info (16 entries = 64 byte) */
92 unsigned long magic; /* HEADER_MAGIC */
93 unsigned long version; /* file version */
94 unsigned long flags; /* combination of FLAG_xx */
95 unsigned long blocksize; /* how many bytes per block (=video frame) */
96 unsigned long bps_average; /* bits per second of the whole stream */
97 unsigned long bps_peak; /* max. of above (audio may be VBR) */
98 unsigned long resume_pos; /* file position to resume to */
99 unsigned long reserved[9]; /* reserved, should be zero */
100
101 /* video info (16 entries = 64 byte) */
102 unsigned long video_format; /* one of VIDEOFORMAT_xxx */
103 unsigned long video_1st_frame; /* byte position of first video frame */
104 unsigned long video_duration; /* total length of video part, in ms */
105 unsigned long video_payload_size; /* total amount of video data, in bytes */
106 unsigned long video_bitrate; /* derived from resolution and frame time, in bps */
107 unsigned long video_frametime; /* frame interval in 11.0592 MHz clocks */
108 long video_preroll; /* video is how much ahead, in 11.0592 MHz clocks */
109 unsigned long video_width; /* in pixels */
110 unsigned long video_height; /* in pixels */
111 unsigned long video_reserved[7]; /* reserved, should be zero */
112
113 /* audio info (16 entries = 64 byte) */
114 unsigned long audio_format; /* one of AUDIOFORMAT_xxx */
115 unsigned long audio_1st_frame; /* byte position of first video frame */
116 unsigned long audio_duration; /* total length of audio part, in ms */
117 unsigned long audio_payload_size; /* total amount of audio data, in bytes */
118 unsigned long audio_avg_bitrate; /* average audio bitrate, in bits per second */
119 unsigned long audio_peak_bitrate; /* maximum bitrate */
120 unsigned long audio_headersize; /* offset to payload in audio frames */
121 long audio_min_associated; /* minimum offset to video frame, in bytes */
122 long audio_max_associated; /* maximum offset to video frame, in bytes */
123 unsigned long audio_reserved[7]; /* reserved, should be zero */
124
125 /* more to come... ? */
126
127 /* Note: padding up to 'blocksize' with zero following this header */
128 } tFileHeader;
129
130 typedef struct /* the little header for all audio blocks */
131 {
132 unsigned long magic; /* AUDIO_MAGIC indicates an audio block */
133 unsigned char previous_block; /* previous how many blocks backwards */
134 unsigned char next_block; /* next how many blocks forward */
135 short associated_video; /* offset to block with corresponding video */
136 unsigned short frame_start; /* offset to first frame starting in this block */
137 unsigned short frame_end; /* offset to behind last frame ending in this block */
138 } tAudioFrameHeader;
139
140
141
142 /****************** globals ******************/
143
144 static struct plugin_api* rb; /* here is a global api struct pointer */
145 static char gPrint[32]; /* a global printf buffer, saves stack */
146
147
148 /* playstate */
149 static struct
150 {
151 enum
152 {
153 paused,
154 playing,
155 } state;
156 bool bAudioUnderrun;
157 bool bVideoUnderrun;
158 bool bHasAudio;
159 bool bHasVideo;
160 int nTimeOSD; /* OSD should stay for this many frames */
161 bool bDirtyOSD; /* OSD needs redraw */
162 bool bRefilling; /* set if refilling buffer */
163 bool bSeeking;
164 int nSeekAcc; /* accelleration value for seek */
165 int nSeekPos; /* current file position for seek */
166 bool bDiskSleep; /* disk is suspended */
167 #if FREQ == 12000000 /* Ondio speed kludge */
168 int nFrameTimeAdjusted;
169 #endif
170 } gPlay;
171
172 /* buffer information */
173 static struct
174 {
175 ssize_t bufsize;
176 int granularity; /* common multiple of block and sector size */
177 unsigned char* pBufStart; /* start of ring buffer */
178 unsigned char* pBufEnd; /* end of ring buffer */
179 unsigned char* pOSD; /* OSD memory (112 bytes for 112*8 pixels) */
180
181 int vidcount; /* how many video blocks are known in a row */
182 unsigned char* pBufFill; /* write pointer for disk, owned by main task */
183 unsigned char* pReadVideo; /* video readout, maintained by timer ISR */
184 unsigned char* pReadAudio; /* audio readout, maintained by demand ISR */
185 bool bEOF; /* flag for end of file */
186 int low_water; /* reload threshold */
187 int high_water; /* end of reload threshold */
188 int spinup_safety; /* safety margin when recalculating low_water */
189 int nReadChunk; /* how much data for normal buffer fill */
190 int nSeekChunk; /* how much data while seeking */
191 } gBuf;
192
193 /* statistics */
194 static struct
195 {
196 int minAudioAvail;
197 int minVideoAvail;
198 int nAudioUnderruns;
199 int nVideoUnderruns;
200 long minSpinup;
201 long maxSpinup;
202 } gStats;
203
204 tFileHeader gFileHdr; /* file header */
205
206 /****************** implementation ******************/
207
208 /* tool function: return how much playable audio/video is left */
209 int Available(unsigned char* pSnapshot)
210 {
211 if (pSnapshot <= gBuf.pBufFill)
212 return gBuf.pBufFill - pSnapshot;
213 else
214 return gBuf.bufsize - (pSnapshot - gBuf.pBufFill);
215 }
216
217 /* debug function to draw buffer indicators */
218 void DrawBuf(void)
219 {
220 int fill, video, audio;
221
222 rb->memset(gBuf.pOSD, 0x10, LCD_WIDTH); /* draw line */
223 gBuf.pOSD[0] = gBuf.pOSD[LCD_WIDTH-1] = 0xFE; /* ends */
224
225 /* calculate new tick positions */
226 fill = 1 + ((gBuf.pBufFill - gBuf.pBufStart) * (LCD_WIDTH-2)) / gBuf.bufsize;
227 video = 1 + ((gBuf.pReadVideo - gBuf.pBufStart) * (LCD_WIDTH-2)) / gBuf.bufsize;
228 audio = 1 + ((gBuf.pReadAudio - gBuf.pBufStart) * (LCD_WIDTH-2)) / gBuf.bufsize;
229
230 gBuf.pOSD[fill] |= 0x20; /* below the line, two pixels */
231 gBuf.pOSD[video] |= 0x08; /* one above */
232 gBuf.pOSD[audio] |= 0x04; /* two above */
233
234 if (gPlay.state == paused) /* we have to draw ourselves */
235 rb->lcd_update_rect(0, LCD_HEIGHT-8, LCD_WIDTH, 8);
236 else
237 gPlay.bDirtyOSD = true; /* redraw it with next timer IRQ */
238 }
239
240
241 /* helper function to draw a position indicator */
242 void DrawPosition(int pos, int total)
243 {
244 int w,h;
245 int sec; /* estimated seconds */
246
247
248 /* print the estimated position */
249 sec = pos / (gFileHdr.bps_average/8);
250 if (sec < 100*60) /* fits into mm:ss format */
251 rb->snprintf(gPrint, sizeof(gPrint), "%02d:%02dm", sec/60, sec%60);
252 else /* a very long clip, hh:mm format */
253 rb->snprintf(gPrint, sizeof(gPrint), "%02d:%02dh", sec/3600, (sec/60)%60);
254 rb->lcd_puts(0, 7, gPrint);
255
256 /* draw a slider over the rest of the line */
257 rb->lcd_getstringsize(gPrint, &w, &h);
258 w++;
259 rb->gui_scrollbar_draw(rb->screens[SCREEN_MAIN],w, LCD_HEIGHT-7, LCD_WIDTH-w,
260 7, total, 0, pos, HORIZONTAL);
261
262 if (gPlay.state == paused) /* we have to draw ourselves */
263 rb->lcd_update_rect(0, LCD_HEIGHT-8, LCD_WIDTH, 8);
264 else /* let the display time do it */
265 {
266 gPlay.nTimeOSD = 70;
267 gPlay.bDirtyOSD = true; /* redraw it with next timer IRQ */
268 }
269 }
270
271
272 /* helper function to change the volume by a certain amount, +/- */
273 void ChangeVolume(int delta)
274 {
275 int minvol = rb->sound_min(SOUND_VOLUME);
276 int maxvol = rb->sound_max(SOUND_VOLUME);
277 int vol = rb->global_settings->volume + delta;
278
279 if (vol > maxvol) vol = maxvol;
280 else if (vol < minvol) vol = minvol;
281 if (vol != rb->global_settings->volume)
282 {
283 rb->sound_set(SOUND_VOLUME, vol);
284 rb->global_settings->volume = vol;
285 rb->snprintf(gPrint, sizeof(gPrint), "Vol: %d dB", vol);
286 rb->lcd_puts(0, 7, gPrint);
287 if (gPlay.state == paused) /* we have to draw ourselves */
288 rb->lcd_update_rect(0, LCD_HEIGHT-8, LCD_WIDTH, 8);
289 else /* let the display time do it */
290 {
291 gPlay.nTimeOSD = 50; /* display it for 50 frames */
292 gPlay.bDirtyOSD = true; /* let the refresh copy it to LCD */
293 }
294 }
295 }
296
297
298 /* helper function to change the LCD contrast by a certain amount, +/- */
299 void ChangeContrast(int delta)
300 {
301 static int mycontrast = -1; /* the "permanent" value while running */
302 int contrast; /* updated value */
303
304 if (mycontrast == -1)
305 mycontrast = rb->global_settings->contrast;
306
307 contrast = mycontrast + delta;
308 if (contrast > 63) contrast = 63;
309 else if (contrast < 5) contrast = 5;
310 if (contrast != mycontrast)
311 {
312 rb->lcd_set_contrast(contrast);
313 mycontrast = contrast;
314 rb->snprintf(gPrint, sizeof(gPrint), "Contrast: %d", contrast);
315 rb->lcd_puts(0, 7, gPrint);
316 if (gPlay.state == paused) /* we have to draw ourselves */
317 rb->lcd_update_rect(0, LCD_HEIGHT-8, LCD_WIDTH, 8);
318 else /* let the display time do it */
319 {
320 gPlay.nTimeOSD = 50; /* display it for 50 frames */
321 gPlay.bDirtyOSD = true; /* let the refresh copy it to LCD */
322 }
323 }
324 }
325
326
327 /* sync the video to the current audio */
328 void SyncVideo(void)
329 {
330 tAudioFrameHeader* pAudioBuf;
331
332 pAudioBuf = (tAudioFrameHeader*)(gBuf.pReadAudio);
333 if (pAudioBuf->magic == AUDIO_MAGIC)
334 {
335 gBuf.vidcount = 0; /* nothing known */
336 /* sync the video position */
337 gBuf.pReadVideo = gBuf.pReadAudio +
338 (long)pAudioBuf->associated_video * (long)gFileHdr.blocksize;
339
340 /* handle possible wrap */
341 if (gBuf.pReadVideo >= gBuf.pBufEnd)
342 gBuf.pReadVideo -= gBuf.bufsize;
343 else if (gBuf.pReadVideo < gBuf.pBufStart)
344 gBuf.pReadVideo += gBuf.bufsize;
345 }
346 }
347
348
349 /* timer interrupt handler to display a frame */
350 void timer4_isr(void)
351 {
352 int available;
353 tAudioFrameHeader* pAudioBuf;
354 int height; /* height to display */
355
356 /* reduce height if we have OSD on */
357 height = gFileHdr.video_height/8;
358 if (gPlay.nTimeOSD > 0)
359 {
360 gPlay.nTimeOSD--;
361 height = MIN(LCD_HEIGHT/8-1, height); /* reserve bottom line */
362 if (gPlay.bDirtyOSD)
363 { /* OSD to bottom line */
364 rb->lcd_blit(gBuf.pOSD, 0, LCD_HEIGHT/8-1,
365 LCD_WIDTH, 1, LCD_WIDTH);
366 gPlay.bDirtyOSD = false;
367 }
368 }
369
370 rb->lcd_blit(gBuf.pReadVideo, 0, 0,
371 gFileHdr.video_width, height, gFileHdr.video_width);
372
373 available = Available(gBuf.pReadVideo);
374
375 /* loop to skip audio frame(s) */
376 while(1)
377 {
378 /* just for the statistics */
379 if (!gBuf.bEOF && available < gStats.minVideoAvail)
380 gStats.minVideoAvail = available;
381
382 if (available <= (int)gFileHdr.blocksize)
383 { /* no data for next frame */
384
385 if (gBuf.bEOF && (gFileHdr.flags & FLAG_LOOP))
386 { /* loop now, assuming the looped clip fits in memory */
387 gBuf.pReadVideo = gBuf.pBufStart + gFileHdr.video_1st_frame;
388 /* FixMe: pReadVideo is incremented below */
389 }
390 else
391 {
392 gPlay.bVideoUnderrun = true;
393 rb->timer_unregister(); /* disable ourselves */
394 return; /* no data available */
395 }
396 }
397 else /* normal advance for next time */
398 {
399 gBuf.pReadVideo += gFileHdr.blocksize;
400 if (gBuf.pReadVideo >= gBuf.pBufEnd)
401 gBuf.pReadVideo -= gBuf.bufsize; /* wraparound */
402 available -= gFileHdr.blocksize;
403 }
404
405 if (!gPlay.bHasAudio)
406 break; /* no need to skip any audio */
407
408 if (gBuf.vidcount)
409 {
410 /* we know the next is a video frame */
411 gBuf.vidcount--;
412 break; /* exit the loop */
413 }
414
415 pAudioBuf = (tAudioFrameHeader*)(gBuf.pReadVideo);
416 if (pAudioBuf->magic == AUDIO_MAGIC)
417 { /* we ran into audio, can happen after seek */
418 gBuf.vidcount = pAudioBuf->next_block;
419 if (gBuf.vidcount)
420 gBuf.vidcount--; /* minus the audio block */
421 }
422 } /* while */
423 }
424
425
426 /* ISR function to get more mp3 data */
427 void GetMoreMp3(unsigned char** start, size_t* size)
428 {
429 int available;
430 int advance;
431
432 tAudioFrameHeader* pAudioBuf = (tAudioFrameHeader*)(gBuf.pReadAudio);
433
434 advance = pAudioBuf->next_block * gFileHdr.blocksize;
435
436 available = Available(gBuf.pReadAudio);
437
438 /* just for the statistics */
439 if (!gBuf.bEOF && available < gStats.minAudioAvail)
440 gStats.minAudioAvail = available;
441
442 if (available < advance + (int)gFileHdr.blocksize || advance == 0)
443 {
444 gPlay.bAudioUnderrun = true;
445 return; /* no data available */
446 }
447
448 gBuf.pReadAudio += advance;
449 if (gBuf.pReadAudio >= gBuf.pBufEnd)
450 gBuf.pReadAudio -= gBuf.bufsize; /* wraparound */
451
452 *start = gBuf.pReadAudio + gFileHdr.audio_headersize;
453 *size = gFileHdr.blocksize - gFileHdr.audio_headersize;
454 }
455
456
457 int WaitForButton(void)
458 {
459 int button;
460
461 do
462 {
463 button = rb->button_get(true);
464 rb->default_event_handler(button);
465 } while ((button & BUTTON_REL) && button != SYS_USB_CONNECTED);
466
467 return button;
468 }
469
470
471 bool WantResume(int fd)
472 {
473 int button;
474
475 rb->lcd_puts(0, 0, "Resume to this");
476 rb->lcd_puts(0, 1, "last position?");
477 rb->lcd_puts(0, 2, "PLAY = yes");
478 rb->lcd_puts(0, 3, "Any Other = no");
479 rb->lcd_puts(0, 4, " (plays from start)");
480 DrawPosition(gFileHdr.resume_pos, rb->filesize(fd));
481 rb->lcd_update();
482
483 button = WaitForButton();
484 return (button == VIDEO_RESUME);
485 }
486
487
488 int SeekTo(int fd, int nPos)
489 {
490 int read_now, got_now;
491
492 if (gPlay.bHasAudio)
493 rb->mp3_play_stop(); /* stop audio ISR */
494 if (gPlay.bHasVideo)
495 rb->timer_unregister(); /* stop the timer */
496
497 rb->lseek(fd, nPos, SEEK_SET);
498
499 gBuf.pBufFill = gBuf.pBufStart; /* all empty */
500 gBuf.pReadVideo = gBuf.pReadAudio = gBuf.pBufStart;
501
502 read_now = gBuf.low_water - 1; /* less than low water, so loading will continue */
503 read_now -= read_now % gBuf.granularity; /* round down to granularity */
504 got_now = rb->read(fd, gBuf.pBufFill, read_now);
505 gBuf.bEOF = (read_now != got_now);
506 gBuf.pBufFill += got_now;
507
508 if (nPos == 0)
509 { /* we seeked to the start */
510 if (gPlay.bHasVideo)
511 gBuf.pReadVideo += gFileHdr.video_1st_frame;
512
513 if (gPlay.bHasAudio)
514 gBuf.pReadAudio += gFileHdr.audio_1st_frame;
515 }
516 else
517 { /* we have to search for the positions */
518 if (gPlay.bHasAudio) /* prepare audio playback, if contained */
519 {
520 /* search for audio frame */
521 while (((tAudioFrameHeader*)(gBuf.pReadAudio))->magic != AUDIO_MAGIC)
522 gBuf.pReadAudio += gFileHdr.blocksize;
523
524 if (gPlay.bHasVideo)
525 SyncVideo(); /* pick the right video for that */
526 }
527 }
528
529 /* synchronous start */
530 gPlay.state = playing;
531 if (gPlay.bHasAudio)
532 {
533 gPlay.bAudioUnderrun = false;
534 rb->mp3_play_data(gBuf.pReadAudio + gFileHdr.audio_headersize,
535 gFileHdr.blocksize - gFileHdr.audio_headersize, GetMoreMp3);
536 rb->mp3_play_pause(true); /* kickoff audio */
537 }
538 if (gPlay.bHasVideo)
539 {
540 gPlay.bVideoUnderrun = false;
541 /* start display interrupt */
542 #if FREQ == 12000000 /* Ondio speed kludge */
543 rb->timer_register(1, NULL, gPlay.nFrameTimeAdjusted, 1, timer4_isr);
544 #else
545 rb->timer_register(1, NULL, gFileHdr.video_frametime, 1, timer4_isr);
546 #endif
547 }
548
549 return 0;
550 }
551
552 /* called from default_event_handler_ex() or at end of playback */
553 void Cleanup(void *fd)
554 {
555 rb->close(*(int*)fd); /* close the file */
556
557 if (gPlay.bHasVideo)
558 rb->timer_unregister(); /* stop video ISR, now I can use the display again */
559
560 if (gPlay.bHasAudio)
561 rb->mp3_play_stop(); /* stop audio ISR */
562
563 /* Turn on backlight timeout (revert to settings) */
564 backlight_use_settings(rb); /* backlight control in lib/helper.c */
565
566 /* restore normal contrast */
567 rb->lcd_set_contrast(rb->global_settings->contrast);
568 }
569
570 /* returns >0 if continue, =0 to stop, <0 to abort (USB) */
571 int PlayTick(int fd)
572 {
573 int button;
574 static int lastbutton = 0;
575 int avail_audio = -1, avail_video = -1;
576 int retval = 1;
577 int filepos;
578
579 /* check buffer level */
580
581 if (gPlay.bHasAudio)
582 avail_audio = Available(gBuf.pReadAudio);
583 if (gPlay.bHasVideo)
584 avail_video = Available(gBuf.pReadVideo);
585
586 if ((gPlay.bHasAudio && avail_audio < gBuf.low_water)
587 || (gPlay.bHasVideo && avail_video < gBuf.low_water))
588 {
589 gPlay.bRefilling = true; /* go to refill mode */
590 }
591
592 if ((!gPlay.bHasAudio || gPlay.bAudioUnderrun)
593 && (!gPlay.bHasVideo || gPlay.bVideoUnderrun)
594 && gBuf.bEOF)
595 {
596 if (gFileHdr.resume_pos)
597 { /* we played til the end, clear resume position */
598 gFileHdr.resume_pos = 0;
599 rb->lseek(fd, 0, SEEK_SET); /* save resume position */
600 rb->write(fd, &gFileHdr, sizeof(gFileHdr));
601 }
602 Cleanup(&fd);
603 return 0; /* all expired */
604 }
605
606 if (!gPlay.bRefilling || gBuf.bEOF)
607 { /* nothing to do */
608 button = rb->button_get_w_tmo(HZ/10);
609 }
610 else
611 { /* refill buffer */
612 int read_now, got_now;
613 int buf_free;
614 long spinup; /* measure the spinup time */
615
616 /* how much can we reload, don't fill completely, would appear empty */
617 buf_free = gBuf.bufsize - MAX(avail_audio, avail_video) - gBuf.high_water;
618 if (buf_free < 0)
619 buf_free = 0; /* just for safety */
620 buf_free -= buf_free % gBuf.granularity; /* round down to granularity */
621
622 /* in one piece max. up to buffer end (wrap after that) */
623 read_now = MIN(buf_free, gBuf.pBufEnd - gBuf.pBufFill);
624
625 /* load piecewise, to stay responsive */
626 read_now = MIN(read_now, gBuf.nReadChunk);
627
628 if (read_now == buf_free)
629 gPlay.bRefilling = false; /* last piece requested */
630
631 spinup = *rb->current_tick; /* in case this is interesting below */
632
633 got_now = rb->read(fd, gBuf.pBufFill, read_now);
634 if (got_now != read_now || read_now == 0)
635 {
636 gBuf.bEOF = true;
637 gPlay.bRefilling = false;
638 }
639
640 if (gPlay.bDiskSleep) /* statistics about the spinup time */
641 {
642 spinup = *rb->current_tick - spinup;
643 gPlay.bDiskSleep = false;
644 if (spinup > gStats.maxSpinup)
645 gStats.maxSpinup = spinup;
646 if (spinup < gStats.minSpinup)
647 gStats.minSpinup = spinup;
648
649 /* recalculate the low water mark from real measurements */
650 gBuf.low_water = (gStats.maxSpinup + gBuf.spinup_safety)
651 * gFileHdr.bps_peak / 8 / HZ;
652 }
653
654 if (!gPlay.bRefilling
655 #ifndef HAVE_FLASH_STORAGE
656 && rb->global_settings->disk_spindown < 20 /* condition for test only */
657 #endif
658 )
659 {
660 rb->ata_sleep(); /* no point in leaving the disk run til timeout */
661 gPlay.bDiskSleep = true;
662 }
663
664 gBuf.pBufFill += got_now;
665 if (gBuf.pBufFill >= gBuf.pBufEnd)
666 gBuf.pBufFill = gBuf.pBufStart; /* wrap */
667
668 rb->yield(); /* have mercy with the other threads */
669 button = rb->button_get(false);
670 }
671
672 /* check keypresses */
673
674 if (button != BUTTON_NONE)
675 {
676 filepos = rb->lseek(fd, 0, SEEK_CUR);
677
678 if (gPlay.bHasVideo) /* video position is more accurate */
679 filepos -= Available(gBuf.pReadVideo); /* take video position */
680 else
681 filepos -= Available(gBuf.pReadAudio); /* else audio */
682
683 switch (button) { /* set exit conditions */
684 case BUTTON_OFF:
685 if (gFileHdr.magic == HEADER_MAGIC /* only if file has header */
686 && !(gFileHdr.flags & FLAG_LOOP)) /* not for stills */
687 {
688 gFileHdr.resume_pos = filepos;
689 rb->lseek(fd, 0, SEEK_SET); /* save resume position */
690 rb->write(fd, &gFileHdr, sizeof(gFileHdr));
691 }
692 Cleanup(&fd);
693 retval = 0; /* signal "stopped" to caller */
694 break;
695 case VIDEO_STOP_SEEK:
696 #ifdef VIDEO_STOP_SEEK_PRE
697 if (lastbutton != VIDEO_STOP_SEEK_PRE)
698 break;
699 #endif
700 if (gPlay.bSeeking)
701 {
702 gPlay.bSeeking = false;
703 gPlay.state = playing;
704 SeekTo(fd, gPlay.nSeekPos);
705 }
706 else if (gPlay.state == playing)
707 {
708 gPlay.state = paused;
709 if (gPlay.bHasAudio)
710 rb->mp3_play_pause(false); /* pause audio */
711 if (gPlay.bHasVideo)
712 rb->timer_unregister(); /* stop the timer */
713 }
714 else if (gPlay.state == paused)
715 {
716 gPlay.state = playing;
717 if (gPlay.bHasAudio)
718 {
719 if (gPlay.bHasVideo)
720 SyncVideo();
721 rb->mp3_play_pause(true); /* play audio */
722 }
723 if (gPlay.bHasVideo)
724 { /* start the video */
725 #if FREQ == 12000000 /* Ondio speed kludge */
726 rb->timer_register(1, NULL,
727 gPlay.nFrameTimeAdjusted, 1, timer4_isr);
728 #else
729 rb->timer_register(1, NULL,
730 gFileHdr.video_frametime, 1, timer4_isr);
731 #endif
732 }
733 }
734 break;
735 case BUTTON_UP:
736 case BUTTON_UP | BUTTON_REPEAT:
737 if (gPlay.bHasAudio)
738 ChangeVolume(1);
739 break;
740 case BUTTON_DOWN:
741 case BUTTON_DOWN | BUTTON_REPEAT:
742 if (gPlay.bHasAudio)
743 ChangeVolume(-1);
744 break;
745 case BUTTON_LEFT:
746 case BUTTON_LEFT | BUTTON_REPEAT:
747 if (!gPlay.bSeeking) /* prepare seek */
748 {
749 gPlay.nSeekPos = filepos;
750 gPlay.bSeeking = true;
751 gPlay.nSeekAcc = 0;
752 }
753 else if (gPlay.nSeekAcc > 0) /* other direction, stop sliding */
754 gPlay.nSeekAcc = 0;
755 else
756 gPlay.nSeekAcc--;
757 break;
758 case BUTTON_RIGHT:
759 case BUTTON_RIGHT | BUTTON_REPEAT:
760 if (!gPlay.bSeeking) /* prepare seek */
761 {
762 gPlay.nSeekPos = filepos;
763 gPlay.bSeeking = true;
764 gPlay.nSeekAcc = 0;
765 }
766 else if (gPlay.nSeekAcc < 0) /* other direction, stop sliding */
767 gPlay.nSeekAcc = 0;
768 else
769 gPlay.nSeekAcc++;
770 break;
771 #ifdef VIDEO_DEBUG
772 case VIDEO_DEBUG: /* debug key */
773 case VIDEO_DEBUG | BUTTON_REPEAT:
774 DrawBuf(); /* show buffer status */
775 gPlay.nTimeOSD = 30;
776 gPlay.bDirtyOSD = true;
777 break;
778 #endif
779 case VIDEO_CONTRAST_DOWN: /* contrast down */
780 case VIDEO_CONTRAST_DOWN | BUTTON_REPEAT:
781 if (gPlay.bHasVideo)
782 ChangeContrast(-1);
783 break;
784 case VIDEO_CONTRAST_UP: /* contrast up */
785 case VIDEO_CONTRAST_UP | BUTTON_REPEAT:
786 if (gPlay.bHasVideo)
787 ChangeContrast(1);
788 break;
789 default:
790 if (rb->default_event_handler_ex(button, Cleanup, &fd)
791 == SYS_USB_CONNECTED)
792 retval = -1; /* signal "aborted" to caller */
793 break;
794 }
795
796 lastbutton = button;
797 } /* if (button != BUTTON_NONE) */
798
799
800 /* handle seeking */
801
802 if (gPlay.bSeeking) /* seeking? */
803 {
804 if (gPlay.nSeekAcc < -MAX_ACC)
805 gPlay.nSeekAcc = -MAX_ACC;
806 else if (gPlay.nSeekAcc > MAX_ACC)
807 gPlay.nSeekAcc = MAX_ACC;
808
809 gPlay.nSeekPos += gPlay.nSeekAcc * gBuf.nSeekChunk;
810 if (gPlay.nSeekPos < 0)
811 gPlay.nSeekPos = 0;
812 if (gPlay.nSeekPos > rb->filesize(fd) - gBuf.granularity)
813 {
814 gPlay.nSeekPos = rb->filesize(fd);
815 gPlay.nSeekPos -= gPlay.nSeekPos % gBuf.granularity;
816 }
817 DrawPosition(gPlay.nSeekPos, rb->filesize(fd));
818 }
819
820
821 /* check + recover underruns */
822
823 if ((gPlay.bAudioUnderrun || gPlay.bVideoUnderrun) && !gBuf.bEOF)
824 {
825 gBuf.spinup_safety += HZ/2; /* add extra spinup time for the future */
826 filepos = rb->lseek(fd, 0, SEEK_CUR);
827
828 if (gPlay.bHasVideo && gPlay.bVideoUnderrun)
829 {
830 gStats.nVideoUnderruns++;
831 filepos -= Available(gBuf.pReadVideo); /* take video position */
832 SeekTo(fd, filepos);
833 }
834 else if (gPlay.bHasAudio && gPlay.bAudioUnderrun)
835 {
836 gStats.nAudioUnderruns++;
837 filepos -= Available(gBuf.pReadAudio); /* else audio */
838 SeekTo(fd, filepos);
839 }
840 }
841
842 return retval;
843 }
844
845
846 int main(char* filename)
847 {
848 int file_size;
849 int fd; /* file descriptor handle */
850 int read_now, got_now;
851 int button = 0;
852 int retval;
853
854 /* try to open the file */
855 fd = rb->open(filename, O_RDWR);
856 if (fd < 0)
857 return PLUGIN_ERROR;
858 file_size = rb->filesize(fd);
859
860 /* reset pitch value to ensure synchronous playback */
861 rb->sound_set_pitch(1000);
862
863 /* init statistics */
864 rb->memset(&gStats, 0, sizeof(gStats));
865 gStats.minAudioAvail = gStats.minVideoAvail = INT_MAX;
866 gStats.minSpinup = INT_MAX;
867
868 /* init playback state */
869 rb->memset(&gPlay, 0, sizeof(gPlay));
870
871 /* init buffer */
872 rb->memset(&gBuf, 0, sizeof(gBuf));
873 gBuf.pOSD = rb->lcd_framebuffer + LCD_WIDTH*7; /* last screen line */
874 gBuf.pBufStart = rb->plugin_get_audio_buffer((size_t *)&gBuf.bufsize);
875 /*gBuf.bufsize = 1700*1024; // test, like 2MB version!!!! */
876 gBuf.pBufFill = gBuf.pBufStart; /* all empty */
877
878 /* load file header */
879 read_now = sizeof(gFileHdr);
880 got_now = rb->read(fd, &gFileHdr, read_now);
881 rb->lseek(fd, 0, SEEK_SET); /* rewind to restart sector-aligned */
882 if (got_now != read_now)
883 {
884 rb->close(fd);
885 return (PLUGIN_ERROR);
886 }
887
888 /* check header */
889 if (gFileHdr.magic != HEADER_MAGIC)
890 { /* old file, use default info */
891 rb->memset(&gFileHdr, 0, sizeof(gFileHdr));
892 gFileHdr.blocksize = SCREENSIZE;
893 if (file_size < SCREENSIZE * FPS) /* less than a second */
894 gFileHdr.flags |= FLAG_LOOP;
895 gFileHdr.video_format = VIDEOFORMAT_RAW;
896 gFileHdr.video_width = LCD_WIDTH;
897 gFileHdr.video_height = LCD_HEIGHT;
898 gFileHdr.video_frametime = 11059200 / FPS;
899 gFileHdr.bps_peak = gFileHdr.bps_average = LCD_WIDTH * LCD_HEIGHT * FPS;
900 }
901
902 #if FREQ == 12000000 /* Ondio speed kludge, 625 / 576 == 12000000 / 11059200 */
903 gPlay.nFrameTimeAdjusted = (gFileHdr.video_frametime * 625) / 576;
904 #endif
905
906 /* continue buffer init: align the end, calc low water, read sizes */
907 gBuf.granularity = gFileHdr.blocksize;
908 while (gBuf.granularity % 512) /* common multiple of sector size */
909 gBuf.granularity *= 2;
910 gBuf.bufsize -= gBuf.bufsize % gBuf.granularity; /* round down */
911 gBuf.pBufEnd = gBuf.pBufStart + gBuf.bufsize;
912 gBuf.low_water = SPINUP_INIT * gFileHdr.bps_peak / 8000;
913 gBuf.spinup_safety = SPINUP_SAFETY * HZ / 1000; /* in time ticks */
914 if (gFileHdr.audio_min_associated < 0)
915 gBuf.high_water = 0 - gFileHdr.audio_min_associated;
916 else
917 gBuf.high_water = 1; /* never fill buffer completely, would appear empty */
918 gBuf.nReadChunk = (CHUNK + gBuf.granularity - 1); /* round up */
919 gBuf.nReadChunk -= gBuf.nReadChunk % gBuf.granularity;/* and align */
920 gBuf.nSeekChunk = rb->filesize(fd) / FF_TICKS;
921 gBuf.nSeekChunk += gBuf.granularity - 1; /* round up */
922 gBuf.nSeekChunk -= gBuf.nSeekChunk % gBuf.granularity; /* and align */
923
924 /* prepare video playback, if contained */
925 if (gFileHdr.video_format == VIDEOFORMAT_RAW)
926 {
927 gPlay.bHasVideo = true;
928 /* Turn off backlight timeout */
929 backlight_force_on(rb); /* backlight control in lib/helper.c */
930 }
931
932 /* prepare audio playback, if contained */
933 if (gFileHdr.audio_format == AUDIOFORMAT_MP3_BITSWAPPED)
934 {
935 gPlay.bHasAudio = true;
936 }
937
938 /* start playback by seeking to zero or resume position */
939 if (gFileHdr.resume_pos && WantResume(fd)) /* ask the user */
940 SeekTo(fd, gFileHdr.resume_pos);
941 else
942 SeekTo(fd, 0);
943
944 /* all that's left to do is keep the buffer full */
945 do /* the main loop */
946 {
947 retval = PlayTick(fd);
948 } while (retval > 0);
949
950 if (retval < 0) /* aborted? */
951 {
952 return PLUGIN_USB_CONNECTED;
953 }
954
955 #ifndef DEBUG /* for release compilations, only display the stats in case of error */
956 if (gStats.nAudioUnderruns || gStats.nVideoUnderruns)
957 #endif
958 {
959 /* display statistics */
960 rb->lcd_clear_display();
961 rb->snprintf(gPrint, sizeof(gPrint), "%d Audio Underruns", gStats.nAudioUnderruns);
962 rb->lcd_puts(0, 0, gPrint);
963 rb->snprintf(gPrint, sizeof(gPrint), "%d Video Underruns", gStats.nVideoUnderruns);
964 rb->lcd_puts(0, 1, gPrint);
965 rb->snprintf(gPrint, sizeof(gPrint), "%d MinAudio bytes", gStats.minAudioAvail);
966 rb->lcd_puts(0, 2, gPrint);
967 rb->snprintf(gPrint, sizeof(gPrint), "%d MinVideo bytes", gStats.minVideoAvail);
968 rb->lcd_puts(0, 3, gPrint);
969 rb->snprintf(gPrint, sizeof(gPrint), "MinSpinup %ld.%02ld", gStats.minSpinup/HZ, gStats.minSpinup%HZ);
970 rb->lcd_puts(0, 4, gPrint);
971 rb->snprintf(gPrint, sizeof(gPrint), "MaxSpinup %ld.%02ld", gStats.maxSpinup/HZ, gStats.maxSpinup%HZ);
972 rb->lcd_puts(0, 5, gPrint);
973 rb->snprintf(gPrint, sizeof(gPrint), "LowWater: %d", gBuf.low_water);
974 rb->lcd_puts(0, 6, gPrint);
975 rb->snprintf(gPrint, sizeof(gPrint), "HighWater: %d", gBuf.high_water);
976 rb->lcd_puts(0, 7, gPrint);
977
978 rb->lcd_update();
979 button = WaitForButton();
980 }
981 return (button == SYS_USB_CONNECTED) ? PLUGIN_USB_CONNECTED : PLUGIN_OK;
982 }
983
984
985 /***************** Plugin Entry Point *****************/
986
987 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
988 {
989 rb = api; /* copy to global api pointer */
990
991 if (parameter == NULL)
992 {
993 rb->splash(HZ*2, "Play .rvf file!");
994 return PLUGIN_ERROR;
995 }
996
997 /* now go ahead and have fun! */
998 return main((char*) parameter);
999 }
1000
1001 #endif /* #ifdef HAVE_LCD_BITMAP */
1002 #endif /* #ifndef SIMULATOR */
1003
My public Rockbox git repo