I'm looking for a video player to use for the intro video for my game in developpement (Dynamite Dreams).
I know that there was a huge work for vcdc (libmpeg2) and recently for xvid.
But I'm not sure it could be used in an independant game without releasing source code (gpl)
So I'm looking for a open and free video codec I can port / use on Dreamcast.
My first try is libtheora, which is fully open and free.
I achieved in compiling it for KOS, here is how to :
- I consider you have a working kos toolchain
- last version of libtheora needs last version of libogg and libvorbis.
So, you have to update the vorbis libraries in kos-ports
Download the last versions : http://www.xiph.org/downloads/
In the kos-ports :
- liboggvorbis\liboggvorbis\libogg\src : put here the files from libogg-1.2.2.zip\libogg-1.2.2\src\ and the same for include
- liboggvorbis\liboggvorbis\libvorbis\lib : put here the files from libvorbis-1.3.2.zip\libvorbis-1.3.2\lib\ and the same for include
- update also the kos-ports/include/ogg and vorbis with the same files in include.
- the only thing I've changes is the config-types.h :
Code: Select all
#ifndef __CONFIG_TYPES_H__
#define __CONFIG_TYPES_H__
#include <sys/cdefs.h>
#include <arch/types.h>
/* these are filled in by configure */
typedef int16 ogg_int16_t;
typedef uint16 ogg_uint16_t;
typedef int32 ogg_int32_t;
typedef uint32 ogg_uint32_t;
typedef int64 ogg_int64_t;
#endif
- you just have to recompile the libs :
Code: Select all
cd kos-ports/liboggvorbis
make clean
make
svn co http://svn.xiph.org/trunk/theora
or download the last stable version from http://www.xiph.org/downloads/
- go into the theora directory, where you have debian,doc,examples... etc and create a directory "build"
- go to the lib directory
- Create this Makefile :
Code: Select all
# KallistiOS Ogg/Vorbis Decoder Library
#
# Library Makefile
# (c)2011 patbier
# Based on KOS Makefiles by Dan Potter
OBJS = analyze.o apiwrapper.o bitpack.o decapiwrapper.o decinfo.o decode.o dequant.o encapiwrapper.o encfrag.o encinfo.o encode.o enquant.o fdct.o fragment.o huffdec.o huffenc.o idct.o info.o internal.o mathops.o mcenc.o quant.o rate.o state.o tokenize.o
KOS_CFLAGS += -I. -I../include -DLITTLE_ENDIAN=1
all: libtheora.a
libtheora.a: $(OBJS)
$(KOS_AR) rcs libtheora.a $(OBJS)
cp $(OBJS) ../build
cp libtheora.a ../build
clean:
-rm -f $(OBJS) libtheora.a
-rm -f ../build/*.o ../build/*.a
include $(KOS_BASE)/Makefile.rules
- to test it, in the theora directory, create a "dc" directory
create a Makefile :
Code: Select all
KOS_CFLAGS += -L../lib -I. -I../include
KOS_CFLAGS += -I. -I../src
TARGET = player.elf
OBJS = player.o
all: clean $(TARGET)
include $(KOS_BASE)/Makefile.rules
clean:
-rm -f $(TARGET) $(OBJS)
$(TARGET): $(OBJS)
kos-cc -o $(TARGET) $(OBJS) $(DATAOBJS) $(OBJEXTRA) -ltheora -loggvorbisplay -lm
Code: Select all
/********************************************************************
* *
* THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE. *
* USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
* GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
* IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
* *
* THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009 *
* by the Xiph.Org Foundation and contributors http://www.xiph.org/ *
* *
********************************************************************
function: example SDL player application; plays Ogg Theora files (with
optional Vorbis audio second stream)
last mod: $Id: player_example.c 17843 2011-02-15 17:19:12Z giles $
********************************************************************/
/* far more complex than most Ogg 'example' programs. The complexity
of maintaining A/V sync is pretty much unavoidable. It's necessary
to actually have audio/video playback to make the hard audio clock
sync actually work. If there's audio playback, there might as well
be simple video playback as well...
A simple 'demux and write back streams' would have been easier,
it's true. */
#if !defined(_GNU_SOURCE)
#define _GNU_SOURCE
#endif
#if !defined(_LARGEFILE_SOURCE)
#define _LARGEFILE_SOURCE
#endif
#if !defined(_LARGEFILE64_SOURCE)
#define _LARGEFILE64_SOURCE
#endif
#if !defined(_FILE_OFFSET_BITS)
#define _FILE_OFFSET_BITS 64
#endif
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#ifndef _REENTRANT
# define _REENTRANT
#endif
#include <kos.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <math.h>
#include <signal.h>
#include "theora/theoradec.h"
#include "vorbis/codec.h"
//#include <SDL.h>
/* yes, this makes us OSS-specific for now. None of SDL, libao, libao2
give us any way to determine hardware timing, and since the
hard/kernel buffer is going to be most of or > a second, that's
just a little bit important */
#if defined(__FreeBSD__)
#include <machine/soundcard.h>
#define AUDIO_DEVICE "/dev/audio"
#elif defined(__NetBSD__) || defined(__OpenBSD__)
#include <soundcard.h>
#define AUDIO_DEVICE "/dev/audio"
#else
//#include <sys/soundcard.h>
//#define AUDIO_DEVICE "/dev/dsp"
#endif
//#include <sys/ioctl.h>
/* Helper; just grab some more compressed bitstream and sync it for
page extraction */
int buffer_data(FILE *in,ogg_sync_state *oy){
char *buffer=ogg_sync_buffer(oy,4096);
int bytes=fread(buffer,1,4096,in);
ogg_sync_wrote(oy,bytes);
return(bytes);
}
/* never forget that globals are a one-way ticket to Hell */
/* Ogg and codec state for demux/decode */
ogg_sync_state oy;
ogg_page og;
ogg_stream_state vo;
ogg_stream_state to;
th_info ti;
th_comment tc;
th_dec_ctx *td;
th_setup_info *ts;
vorbis_info vi;
vorbis_dsp_state vd;
vorbis_block vb;
vorbis_comment vc;
th_pixel_fmt px_fmt;
int theora_p=0;
int vorbis_p=0;
int stateflag=0;
/* SDL Video playback structures */
//SDL_Surface *screen;
//SDL_Overlay *yuv_overlay;
//SDL_Rect rect;
unsigned char *RGBbuffer;
#define OC_CLAMP255(_x) ((unsigned char)((((_x)<0)-1)&((_x)|-((_x)>255))))
/* single frame video buffering */
int videobuf_ready=0;
ogg_int64_t videobuf_granulepos=-1;
double videobuf_time=0;
/* single audio fragment audio buffering */
int audiobuf_fill=0;
int audiobuf_ready=0;
ogg_int16_t *audiobuf;
ogg_int64_t audiobuf_granulepos=0; /* time position of last sample */
/* audio / video synchronization tracking:
Since this will make it to Google at some point and lots of people
search for how to do this, a quick rundown of a practical A/V sync
strategy under Linux [the UNIX where Everything Is Hard]. Naturally,
this works on other platforms using OSS for sound as well.
In OSS, we don't have reliable access to any precise information on
the exact current playback position (that, of course would have been
too easy; the kernel folks like to keep us app people working hard
doing simple things that should have been solved once and abstracted
long ago). Hopefully ALSA solves this a little better; we'll probably
use that once ALSA is the standard in the stable kernel.
We can't use the system clock for a/v sync because audio is hard
synced to its own clock, and both the system and audio clocks suffer
from wobble, drift, and a lack of accuracy that can be guaranteed to
add a reliable percent or so of error. After ten seconds, that's
100ms. We can't drift by half a second every minute.
Although OSS can't generally tell us where the audio playback pointer
is, we do know that if we work in complete audio fragments and keep
the kernel buffer full, a blocking select on the audio buffer will
give us a writable fragment immediately after playback finishes with
it. We assume at that point that we know the exact number of bytes in
the kernel buffer that have not been played (total fragments minus
one) and calculate clock drift between audio and system then (and only
then). Damp the sync correction fraction, apply, and walla: A
reliable A/V clock that even works if it's interrupted. */
long audiofd_totalsize=-1;
int audiofd_fragsize; /* read and write only complete fragments
so that SNDCTL_DSP_GETOSPACE is
accurate immediately after a bank
switch */
int audiofd=-1;
ogg_int64_t audiofd_timer_calibrate=-1;
/* helper: push a page into the appropriate steam */
/* this can be done blindly; a stream won't accept a page
that doesn't belong to it */
static int queue_page(ogg_page *page){
if(theora_p)ogg_stream_pagein(&to,page);
if(vorbis_p)ogg_stream_pagein(&vo,page);
return 0;
}
/* Report the encoder-specified colorspace for the video, if any.
We don't actually make use of the information in this example;
a real player should attempt to perform color correction for
whatever display device it supports. */
static void report_colorspace(th_info *ti)
{
switch(ti->colorspace){
case TH_CS_UNSPECIFIED:
/* nothing to report */
break;;
case TH_CS_ITU_REC_470M:
printf(" encoder specified ITU Rec 470M (NTSC) color.\n");
break;;
case TH_CS_ITU_REC_470BG:
printf(" encoder specified ITU Rec 470BG (PAL) color.\n");
break;;
default:
printf("warning: encoder specified unknown colorspace (%d).\n",
ti->colorspace);
break;;
}
}
/* dump the theora (or vorbis) comment header */
static int dump_comments(th_comment *tc){
int i, len;
char *value;
FILE *out=stdout;
printf("Encoded by %s\n",tc->vendor);
if(tc->comments){
printf("theora comment header:\n");
for(i=0;i<tc->comments;i++){
if(tc->user_comments[i]){
len=tc->comment_lengths[i];
value=malloc(len+1);
memcpy(value,tc->user_comments[i],len);
value[len]='\0';
//fprintf(out, "\t%s\n", value);
free(value);
}
}
}
return(0);
}
static void open_audio(){}
/* clean quit on Ctrl-C for SDL and thread shutdown as per SDL example
(we don't use any threads, but libSDL does) */
int got_sigint=0;
static void sigint_handler (int signal) {
got_sigint = 1;
}
static void open_video(void){}
/* call this only immediately after unblocking from a full kernel
having a newly empty fragment or at the point of DMA restart */
void audio_calibrate_timer(int restart){
struct timeval tv;
ogg_int64_t current_sample;
ogg_int64_t new_time;
gettimeofday(&tv,0);
new_time=tv.tv_sec*1000+tv.tv_usec/1000;
if(restart){
current_sample=audiobuf_granulepos-audiobuf_fill/2/vi.channels;
}else
current_sample=audiobuf_granulepos-
(audiobuf_fill+audiofd_totalsize-audiofd_fragsize)/2/vi.channels;
new_time-=1000*current_sample/vi.rate;
audiofd_timer_calibrate=new_time;
}
/* get relative time since beginning playback, compensating for A/V
drift */
double get_time(){
static ogg_int64_t last=0;
static ogg_int64_t up=0;
ogg_int64_t now;
struct timeval tv;
gettimeofday(&tv,0);
now=tv.tv_sec*1000+tv.tv_usec/1000;
if(audiofd_timer_calibrate==-1)audiofd_timer_calibrate=last=now;
if(audiofd<0){
/* no audio timer to worry about, we can just use the system clock */
/* only one complication: If the process is suspended, we should
reset timing to account for the gap in play time. Do it the
easy/hack way */
if(now-last>1000)audiofd_timer_calibrate+=(now-last);
last=now;
}
if(now-up>200){
double timebase=(now-audiofd_timer_calibrate)*.001;
int hundredths=timebase*100-(long)timebase*100;
int seconds=(long)timebase%60;
int minutes=((long)timebase/60)%60;
int hours=(long)timebase/3600;
printf(" Playing: %d:%02d:%02d.%02d \r",
hours,minutes,seconds,hundredths);
up=now;
}
return (now-audiofd_timer_calibrate)*.001;
}
void audio_write_nonblocking(void){}
static void audio_close(void){}
static void video_write(void){}
int main(int argc,char *const *argv){
int pp_level_max;
int pp_level;
int pp_inc;
int i,j;
ogg_packet op;
FILE *infile = stdin;
int frames = 0;
int dropped = 0;
vid_set_mode (DM_640x480, PM_RGB565);
pvr_init_defaults();
printf("Debut Theora\n\n");
infile=fopen("/cd/Movie.OGG","rb");
if(infile==NULL){
printf("Unable to open '%s' for playback.\n", argv[1]);
exit(1);
}
/* start up Ogg stream synchronization layer */
ogg_sync_init(&oy);
/* init supporting Vorbis structures needed in header parsing */
vorbis_info_init(&vi);
vorbis_comment_init(&vc);
/* init supporting Theora structures needed in header parsing */
th_comment_init(&tc);
th_info_init(&ti);
/* Ogg file open; parse the headers */
/* Only interested in Vorbis/Theora streams */
while(!stateflag){
int ret=buffer_data(infile,&oy);
if(ret==0)break;
while(ogg_sync_pageout(&oy,&og)>0){
ogg_stream_state test;
/* is this a mandated initial header? If not, stop parsing */
if(!ogg_page_bos(&og)){
/* don't leak the page; get it into the appropriate stream */
queue_page(&og);
stateflag=1;
break;
}
ogg_stream_init(&test,ogg_page_serialno(&og));
ogg_stream_pagein(&test,&og);
ogg_stream_packetout(&test,&op);
/* identify the codec: try theora */
if(!theora_p && th_decode_headerin(&ti,&tc,&ts,&op)>=0){
/* it is theora */
memcpy(&to,&test,sizeof(test));
theora_p=1;
}else if(!vorbis_p && vorbis_synthesis_headerin(&vi,&vc,&op)>=0){
/* it is vorbis */
memcpy(&vo,&test,sizeof(test));
vorbis_p=1;
}else{
/* whatever it is, we don't care about it */
ogg_stream_clear(&test);
}
}
/* fall through to non-bos page parsing */
}
/* we're expecting more header packets. */
while((theora_p && theora_p<3) || (vorbis_p && vorbis_p<3)){
int ret;
/* look for further theora headers */
while(theora_p && (theora_p<3) && (ret=ogg_stream_packetout(&to,&op))){
if(ret<0){
printf("Error parsing Theora stream headers; "
"corrupt stream?\n");
exit(1);
}
if(!th_decode_headerin(&ti,&tc,&ts,&op)){
printf("Error parsing Theora stream headers; "
"corrupt stream?\n");
exit(1);
}
theora_p++;
}
/* look for more vorbis header packets */
while(vorbis_p && (vorbis_p<3) && (ret=ogg_stream_packetout(&vo,&op))){
if(ret<0){
printf("Error parsing Vorbis stream headers; corrupt stream?\n");
exit(1);
}
if(vorbis_synthesis_headerin(&vi,&vc,&op)){
printf("Error parsing Vorbis stream headers; corrupt stream?\n");
exit(1);
}
vorbis_p++;
if(vorbis_p==3)break;
}
/* The header pages/packets will arrive before anything else we
care about, or the stream is not obeying spec */
if(ogg_sync_pageout(&oy,&og)>0){
queue_page(&og); /* demux into the appropriate stream */
}else{
int ret=buffer_data(infile,&oy); /* someone needs more data */
if(ret==0){
printf("End of file while searching for codec headers.\n");
exit(1);
}
}
}
/* and now we have it all. initialize decoders */
if(theora_p){
td=th_decode_alloc(&ti,ts);
printf("Ogg logical stream %lx is Theora %dx%d %.02f fps",
to.serialno,ti.pic_width,ti.pic_height,
(double)ti.fps_numerator/ti.fps_denominator);
px_fmt=ti.pixel_fmt;
switch(ti.pixel_fmt){
case TH_PF_420: printf(" 4:2:0 video\n"); break;
case TH_PF_422: printf(" 4:2:2 video\n"); break;
case TH_PF_444: printf(" 4:4:4 video\n"); break;
case TH_PF_RSVD:
default:
printf(" video\n (UNKNOWN Chroma sampling!)\n");
break;
}
if(ti.pic_width!=ti.frame_width || ti.pic_height!=ti.frame_height)
printf(" Frame content is %dx%d with offset (%d,%d).\n",
ti.frame_width, ti.frame_height, ti.pic_x, ti.pic_y);
report_colorspace(&ti);
dump_comments(&tc);
th_decode_ctl(td,TH_DECCTL_GET_PPLEVEL_MAX,&pp_level_max,
sizeof(pp_level_max));
pp_level=pp_level_max;
th_decode_ctl(td,TH_DECCTL_SET_PPLEVEL,&pp_level,sizeof(pp_level));
pp_inc=0;
/*{
int arg = 0xffff;
th_decode_ctl(td,TH_DECCTL_SET_TELEMETRY_MBMODE,&arg,sizeof(arg));
th_decode_ctl(td,TH_DECCTL_SET_TELEMETRY_MV,&arg,sizeof(arg));
th_decode_ctl(td,TH_DECCTL_SET_TELEMETRY_QI,&arg,sizeof(arg));
arg=10;
th_decode_ctl(td,TH_DECCTL_SET_TELEMETRY_BITS,&arg,sizeof(arg));
}*/
}else{
/* tear down the partial theora setup */
th_info_clear(&ti);
th_comment_clear(&tc);
}
th_setup_free(ts);
if(vorbis_p){
vorbis_synthesis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
printf("Ogg logical stream %lx is Vorbis %d channel %ld Hz audio.\n",
vo.serialno,vi.channels,vi.rate);
}else{
/* tear down the partial vorbis setup */
vorbis_info_clear(&vi);
vorbis_comment_clear(&vc);
}
/* open audio */
if(vorbis_p)open_audio();
/* open video */
if(theora_p)open_video();
printf("Apres open video& audio\n");
/* install signal handler as SDL clobbered the default */
signal (SIGINT, sigint_handler);
printf("Apres signal\n");
/* on to the main decode loop. We assume in this example that audio
and video start roughly together, and don't begin playback until
we have a start frame for both. This is not necessarily a valid
assumption in Ogg A/V streams! It will always be true of the
example_encoder (and most streams) though. */
stateflag=0; /* playback has not begun */
while(!got_sigint){
/* we want a video and audio frame ready to go at all times. If
we have to buffer incoming, buffer the compressed data (ie, let
ogg do the buffering) */
while(vorbis_p && !audiobuf_ready){
int ret;
float **pcm;
/* if there's pending, decoded audio, grab it */
if((ret=vorbis_synthesis_pcmout(&vd,&pcm))>0){
int count=audiobuf_fill/2;
int maxsamples=(audiofd_fragsize-audiobuf_fill)/2/vi.channels;
for(i=0;i<ret && i<maxsamples;i++)
for(j=0;j<vi.channels;j++){
int val=rint(pcm[j][i]*32767.f);
if(val>32767)val=32767;
if(val<-32768)val=-32768;
audiobuf[count++]=val;
}
vorbis_synthesis_read(&vd,i);
audiobuf_fill+=i*vi.channels*2;
if(audiobuf_fill==audiofd_fragsize)audiobuf_ready=1;
if(vd.granulepos>=0)
audiobuf_granulepos=vd.granulepos-ret+i;
else
audiobuf_granulepos+=i;
}else{
/* no pending audio; is there a pending packet to decode? */
if(ogg_stream_packetout(&vo,&op)>0){
if(vorbis_synthesis(&vb,&op)==0) /* test for success! */
vorbis_synthesis_blockin(&vd,&vb);
}else /* we need more data; break out to suck in another page */
break;
}
}
while(theora_p && !videobuf_ready){
/* theora is one in, one out... */
if(ogg_stream_packetout(&to,&op)>0){
if(pp_inc){
pp_level+=pp_inc;
th_decode_ctl(td,TH_DECCTL_SET_PPLEVEL,&pp_level,
sizeof(pp_level));
pp_inc=0;
}
/*HACK: This should be set after a seek or a gap, but we might not have
a granulepos for the first packet (we only have them for the last
packet on a page), so we just set it as often as we get it.
To do this right, we should back-track from the last packet on the
page and compute the correct granulepos for the first packet after
a seek or a gap.*/
if(op.granulepos>=0){
th_decode_ctl(td,TH_DECCTL_SET_GRANPOS,&op.granulepos,
sizeof(op.granulepos));
}
if(th_decode_packetin(td,&op,&videobuf_granulepos)==0){
videobuf_time=th_granule_time(td,videobuf_granulepos);
frames++;
printf("frame %d dropped %d\n",frames,dropped);
/* is it already too old to be useful? This is only actually
useful cosmetically after a SIGSTOP. Note that we have to
decode the frame even if we don't show it (for now) due to
keyframing. Soon enough libtheora will be able to deal
with non-keyframe seeks. */
if(videobuf_time>=get_time())
videobuf_ready=1;
else{
/*If we are too slow, reduce the pp level.*/
pp_inc=pp_level>0?-1:0;
dropped++;
printf("frame %d dropped %d\n",frames,dropped);
}
}
}else
break;
}
if(!videobuf_ready && !audiobuf_ready && feof(infile))break;
if(!videobuf_ready || !audiobuf_ready){
/* no data yet for somebody. Grab another page */
buffer_data(infile,&oy);
while(ogg_sync_pageout(&oy,&og)>0){
queue_page(&og);
}
}
/* If playback has begun, top audio buffer off immediately. */
if(stateflag) audio_write_nonblocking();
/* are we at or past time for this video frame? */
if(stateflag && videobuf_ready && videobuf_time<=get_time()){
video_write();
videobuf_ready=0;
}
if(stateflag &&
(audiobuf_ready || !vorbis_p) &&
(videobuf_ready || !theora_p) &&
!got_sigint){
/* we have an audio frame ready (which means the audio buffer is
full), it's not time to play video, so wait until one of the
audio buffer is ready or it's near time to play video */
/* set up select wait on the audiobuffer and a timeout for video */
struct timeval timeout;
fd_set writefs;
fd_set empty;
int n=0;
FD_ZERO(&writefs);
FD_ZERO(&empty);
if(audiofd>=0){
FD_SET(audiofd,&writefs);
n=audiofd+1;
}
if(theora_p){
double tdiff;
long milliseconds;
tdiff=videobuf_time-get_time();
/*If we have lots of extra time, increase the post-processing level.*/
if(tdiff>ti.fps_denominator*0.25/ti.fps_numerator){
pp_inc=pp_level<pp_level_max?1:0;
}
else if(tdiff<ti.fps_denominator*0.05/ti.fps_numerator){
pp_inc=pp_level>0?-1:0;
}
milliseconds=tdiff*1000-5;
if(milliseconds>500)milliseconds=500;
if(milliseconds>0){
timeout.tv_sec=milliseconds/1000;
timeout.tv_usec=(milliseconds%1000)*1000;
//n=select(n,&empty,&writefs,&empty,&timeout);
//if(n)audio_calibrate_timer(0);
}
}else{
//select(n,&empty,&writefs,&empty,NULL);
}
}
/* if our buffers either don't exist or are ready to go,
we can begin playback */
if((!theora_p || videobuf_ready) &&
(!vorbis_p || audiobuf_ready))stateflag=1;
/* same if we've run out of input */
if(feof(infile))stateflag=1;
}
/* tear it all down */
audio_close();
//SDL_Quit();
printf("\n");
printf("\nDone.\n");
return(0);
}
- now you need a video file, I used "Super" to create a theora video file. I burned it on a cd.
- the decoder works but it seems slow.
So, if someone here tries and have a look, does it seem possible to optimize and use the libtheora ? I'd like to use a 320*240 with a reasonable bitrate (1000 kbs).
Another codec idea ?
Thanks for reading this long topic !