int main(int argc,char *argv[]){
int i,j;
ogg_packet op;
FILE *infile = stdin;
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */
/* Beware the evil ifdef. We avoid these where we can, but this one we
cannot. Don't add any more, you'll probably go to hell if you do. */
_setmode( _fileno( stdin ), _O_BINARY );
#endif
/* open the input file if any */
if(argc==2){
infile=fopen(argv[1],"rb");
if(infile==NULL){
fprintf(stderr,"Unable to open '%s' for playback.\n", argv[1]);
exit(1);
}
}
if(argc>2){
usage();
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 */
theora_comment_init(&tc);
theora_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 && theora_decode_header(&ti,&tc,&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){
fprintf(stderr,"Error parsing Theora stream headers; corrupt stream?\n");
exit(1);
}
if(theora_decode_header(&ti,&tc,&op)){
printf("Error parsing Theora stream headers; corrupt stream?\n");
exit(1);
}
theora_p++;
if(theora_p==3)break;
}
/* look for more vorbis header packets */
while(vorbis_p && (vorbis_p<3) && (ret=ogg_stream_packetout(&vo,&op))){
if(ret<0){
fprintf(stderr,"Error parsing Vorbis stream headers; corrupt stream?\n");
exit(1);
}
if(vorbis_synthesis_headerin(&vi,&vc,&op)){
fprintf(stderr,"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){
fprintf(stderr,"End of file while searching for codec headers.\n");
exit(1);
}
}
}
/* and now we have it all. initialize decoders */
if(theora_p){
theora_decode_init(&td,&ti);
printf("Ogg logical stream %x is Theora %dx%d %.02f fps video\n",
(unsigned int)to.serialno,ti.width,ti.height,
(double)ti.fps_numerator/ti.fps_denominator);
if(ti.width!=ti.frame_width || ti.height!=ti.frame_height)
printf(" Frame content is %dx%d with offset (%d,%d).\n",
ti.frame_width, ti.frame_height, ti.offset_x, ti.offset_y);
report_colorspace(&ti);
dump_comments(&tc);
}else{
/* tear down the partial theora setup */
theora_info_clear(&ti);
theora_comment_clear(&tc);
}
if(vorbis_p){
vorbis_synthesis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
fprintf(stderr,"Ogg logical stream %x is Vorbis %d channel %d Hz audio.\n",
(unsigned int)vo.serialno,vi.channels,(int)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();
/* install signal handler as SDL clobbered the default */
signal (SIGINT, sigint_handler);
/* 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){
theora_decode_packetin(&td,&op);
videobuf_granulepos=td.granulepos;
videobuf_time=theora_granule_time(&td,videobuf_granulepos);
/* 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
break;
}
if(!videobuf_ready && !audiobuf_ready && feof(infile))break;
if(!videobuf_ready || !audiobuf_ready){
/* no data yet for somebody. Grab another page */
int bytes=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){
long milliseconds=(videobuf_time-get_time())*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();
if(vorbis_p){
ogg_stream_clear(&vo);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
}
if(theora_p){
ogg_stream_clear(&to);
theora_clear(&td);
theora_comment_clear(&tc);
theora_info_clear(&ti);
}
ogg_sync_clear(&oy);
if(infile && infile!=stdin)fclose(infile);
fprintf(stderr,
"\r "
"\nDone.\n");
return(0);
}
static void test_tx_valid(bool is_valid, struct bp_hashtab *input_map,
cstring *tx_ser, bool enforce_p2sh)
{
struct bp_tx tx;
bp_tx_init(&tx);
struct const_buffer buf = { tx_ser->str, tx_ser->len };
assert(deser_bp_tx(&tx, &buf) == true);
if (is_valid) {
/* checking for valid tx; !bp_tx_valid implies test fail */
assert(bp_tx_valid(&tx) == true);
} else {
/* checking for invalid tx; bp_tx_valid==false implies test
* succeeded; no more work to do; bp_tx_valid==true
* implies the test will detect the invalid condition
* further down in the code
*/
if (bp_tx_valid(&tx) == false)
goto out;
}
bp_tx_calc_sha256(&tx);
unsigned int i;
for (i = 0; i < tx.vin->len; i++) {
struct bp_txin *txin;
txin = parr_idx(tx.vin, i);
assert(txin != NULL);
cstring *scriptPubKey = bp_hashtab_get(input_map,
&txin->prevout);
if (scriptPubKey == NULL) {
if (!is_valid) {
/* if testing tx_invalid.json, missing input
* is invalid, and therefore correct
*/
continue;
}
char tx_hexstr[BU256_STRSZ], hexstr[BU256_STRSZ];
bu256_hex(tx_hexstr, &tx.sha256);
bu256_hex(hexstr, &txin->prevout.hash);
dump_comments();
fprintf(stderr,
"tx-valid: TX %s\n"
"tx-valid: prevout (%s, %u) not found\n",
tx_hexstr, hexstr, txin->prevout.n);
assert(scriptPubKey != NULL);
}
bool rc = bp_script_verify(txin->scriptSig, scriptPubKey,
&tx, i,
enforce_p2sh ? SCRIPT_VERIFY_P2SH :
SCRIPT_VERIFY_NONE, 0);
if (rc != is_valid) {
char tx_hexstr[BU256_STRSZ];
bu256_hex(tx_hexstr, &tx.sha256);
dump_comments();
fprintf(stderr,
"tx-valid: TX %s\n"
"tx-valid: txin %u script verification failed\n",
tx_hexstr, i);
assert(rc == is_valid);
}
}
out:
bp_tx_free(&tx);
}
bool CTheoraPlayer::playVideo(
//Plays specified OGG Theora file to screen surface.
//If screen == NULL, then this method will test that the file is playable
//by decoding it as fast as possible but not displaying anything.
//
//Returns: whether playback was successful
CStretchyBuffer& buffer, SDL_Surface *screen,
const int x, const int y) //[default=(0,0)]
{
//init
theora_p = vorbis_p = 0;
startticks = 0;
bool bSkippedLastFrame = false;
// 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
theora_comment_init(&tc);
theora_info_init(&ti);
if (!screen)
ti.quick_p = 1;
ti.quality = 63;
if (!parseHeaders(buffer))
return false;
// force audio off
vorbis_p = 0;
// initialize decoders
if (theora_p) {
theora_decode_init(&td,&ti);
#if 0
printf("Ogg logical stream %x is Theora %dx%d %.02f fps video\n"
" Frame content is %dx%d with offset (%d,%d).\n",
to.serialno,ti.width,ti.height, (double)ti.fps_numerator/ti.fps_denominator,
ti.frame_width, ti.frame_height, ti.offset_x, ti.offset_y);
//report_colorspace(&ti); //we're not using this info for anything
dump_comments(&tc);
#endif
} else {
// tear down the partial theora setup
theora_info_clear(&ti);
theora_comment_clear(&tc);
}
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
SDL_Overlay *yuv_overlay = NULL;
if (theora_p && screen)
yuv_overlay = open_video(screen);
// single frame video buffering
ogg_packet op;
ogg_int64_t videobuf_granulepos=-1;
double videobuf_time=0;
double last_frame_time = 0;
bool hasdatatobuffer = true;
// Main loop
bool audiobuf_ready=false;
bool videobuf_ready=false;
bool playbackdone = (yuv_overlay == NULL);
bool isPlaying = false;
bool bBreakout = false;
while (!playbackdone)
{
// break out on SDL quit event
SDL_Event event;
if (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT: playbackdone = bBreakout = true; break;
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE)
playbackdone = bBreakout = true;
break;
default: break;
}
}
while (theora_p && !videobuf_ready) {
// get one video packet...
if (ogg_stream_packetout(&to,&op)>0)
{
theora_decode_packetin(&td,&op);
videobuf_granulepos=td.granulepos;
videobuf_time=theora_granule_time(&td,videobuf_granulepos);
#if 0
//Without sound channels to synch to, don't need to worry about skipping frames when slow.
// update the frame counter
//++frameNum;
// check if this frame time has not passed yet.
// If the frame is late we need to decode additional
// ones and keep looping, since theora at this stage
// needs to decode all frames.
const double now=get_time();
const double delay=videobuf_time-now;
if(delay>=0.0){
/// got a good frame, not late, ready to break out
videobuf_ready=true;
} else if(now-last_frame_time>=1.0) {
// display at least one frame per second, regardless
videobuf_ready=true;
} else {
//Need to catch up -- no time to display frame.
if (bSkippedLastFrame) //only allow skipping one frame in a row
videobuf_ready = true; //show anyway
else
bSkippedLastFrame = true;
//printf("dropping frame %d (%.3fs behind)\n", frameNum, -delay);
}
#else
videobuf_ready = true; //show every frame
#endif
} else {
// need more data
break;
}
}
if (!hasdatatobuffer && !videobuf_ready && !audiobuf_ready) {
isPlaying = false;
playbackdone = true;
}
//If we're set for the next frame, sleep.
//In other words, don't show frames too rapidly.
if((!theora_p || videobuf_ready) &&
(!vorbis_p || audiobuf_ready))
{
const int ticks = (int)(1000*(videobuf_time-get_time()));
if(ticks>0 && screen) //don't need to sleep if only testing file
SDL_Delay(ticks);
}
if (videobuf_ready)
{
// time to write our cached frame
if (screen)
{
const bool bRes = video_write(screen, yuv_overlay, x, y);
if (!bRes) //couldn't display image
playbackdone = bBreakout = true;
}
videobuf_ready=false;
last_frame_time=get_time();
bSkippedLastFrame = false;
// if audio has not started (first frame) then start it
if ((!isPlaying)&&(vorbis_p)) {
start_audio();
isPlaying = true;
}
}
// HACK: always look for more audio data
audiobuf_ready=false;
// buffer compressed data every loop
if (hasdatatobuffer) {
hasdatatobuffer = buffer_data(&oy, buffer) > 0;
if (!hasdatatobuffer) {
//printf("Ogg buffering stopped, end of file reached.\n");
}
}
if (ogg_sync_pageout(&oy,&og)>0)
queue_page(&og);
} // playbackdone
// show number of video frames decoded
//printf("\nFrames decoded: %d\n", frameNum);
// deinit
if (vorbis_p) {
audio_close();
ogg_stream_clear(&vo);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
}
if (theora_p) {
if (yuv_overlay)
SDL_FreeYUVOverlay(yuv_overlay);
ogg_stream_clear(&to);
theora_clear(&td);
theora_comment_clear(&tc);
theora_info_clear(&ti);
}
ogg_sync_clear(&oy);
//If broken out of testing, return false since entire file was not verified.
return !bBreakout || screen != NULL;
}
int main(int argc,char *argv[]){
ogg_packet op;
int long_option_index;
int c;
struct timeb start;
struct timeb after;
struct timeb last;
int fps_only=0;
int frames = 0;
FILE *infile = stdin;
outfile = stdout;
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode on windows. */
/* Beware the evil ifdef. We avoid these where we can, but this one we
cannot. Don't add any more, you'll probably go to hell if you do. */
_setmode( _fileno( stdin ), _O_BINARY );
_setmode( _fileno( stdout ), _O_BINARY );
#endif
/* Process option arguments. */
while((c=getopt_long(argc,argv,optstring,options,&long_option_index))!=EOF){
switch(c){
case 'o':
if(strcmp(optarg,"-")!=0){
outfile=fopen(optarg,"wb");
if(outfile==NULL){
fprintf(stderr,"Unable to open output file '%s'\n", optarg);
exit(1);
}
}else{
outfile=stdout;
}
break;
case 'c':
crop=1;
break;
case 'r':
raw=1;
break;
case 'f':
fps_only = 1;
outfile = NULL;
break;
default:
usage();
}
}
if(optind<argc){
infile=fopen(argv[optind],"rb");
if(infile==NULL){
fprintf(stderr,"Unable to open '%s' for extraction.\n", argv[optind]);
exit(1);
}
if(++optind<argc){
usage();
exit(1);
}
}
/*Ok, Ogg parsing.
The idea here is we have a bitstream that is made up of Ogg pages.
The libogg sync layer will find them for us.
There may be pages from several logical streams interleaved; we find the
first theora stream and ignore any others.
Then we pass the pages for our stream to the libogg stream layer which
assembles our original set of packets out of them.
It's the packets that libtheora actually knows how to handle.*/
/* start up Ogg stream synchronization layer */
ogg_sync_init(&oy);
/* init supporting Theora structures needed in header parsing */
th_comment_init(&tc);
th_info_init(&ti);
/*Ogg file open; parse the headers.
Theora (like Vorbis) depends on some initial header packets for decoder
setup and initialization.
We retrieve these first before entering the main decode loop.*/
/* Only interested in Theora streams */
while(!stateflag){
int ret=buffer_data(infile,&oy);
if(ret==0)break;
while(ogg_sync_pageout(&oy,&og)>0){
int got_packet;
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);
got_packet = ogg_stream_packetpeek(&test,&op);
/* identify the codec: try theora */
if((got_packet==1) && !theora_p && (theora_processing_headers=
th_decode_headerin(&ti,&tc,&ts,&op))>=0){
/* it is theora -- save this stream state */
memcpy(&to,&test,sizeof(test));
theora_p=1;
/*Advance past the successfully processed header.*/
if(theora_processing_headers)ogg_stream_packetout(&to,NULL);
}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_processing_headers){
int ret;
/* look for further theora headers */
while(theora_processing_headers&&(ret=ogg_stream_packetpeek(&to,&op))){
if(ret<0)continue;
theora_processing_headers=th_decode_headerin(&ti,&tc,&ts,&op);
if(theora_processing_headers<0){
fprintf(stderr,"Error parsing Theora stream headers; "
"corrupt stream?\n");
exit(1);
}
else if(theora_processing_headers>0){
/*Advance past the successfully processed header.*/
ogg_stream_packetout(&to,NULL);
}
theora_p++;
}
/*Stop now so we don't fail if there aren't enough pages in a short
stream.*/
if(!(theora_p && theora_processing_headers))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){
fprintf(stderr,"End of file while searching for codec headers.\n");
exit(1);
}
}
}
/* and now we have it all. initialize decoders */
if(theora_p){
dump_comments(&tc);
td=th_decode_alloc(&ti,ts);
fprintf(stderr,"Ogg logical stream %lx is Theora %dx%d %.02f fps video\n"
"Encoded frame content is %dx%d with %dx%d offset\n",
to.serialno,ti.frame_width,ti.frame_height,
(double)ti.fps_numerator/ti.fps_denominator,
ti.pic_width,ti.pic_height,ti.pic_x,ti.pic_y);
/*{
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);
}
/*Either way, we're done with the codec setup data.*/
th_setup_free(ts);
/* open video */
if(theora_p)open_video();
if(!raw && outfile){
static const char *CHROMA_TYPES[4]={"420jpeg",NULL,"422jpeg","444"};
int width;
int height;
if(ti.pixel_fmt>=4||ti.pixel_fmt==TH_PF_RSVD){
fprintf(stderr,"Unknown pixel format: %i\n",ti.pixel_fmt);
exit(1);
}
if(crop){
int hdec;
int vdec;
hdec=!(ti.pixel_fmt&1);
vdec=!(ti.pixel_fmt&2);
if((ti.pic_x&hdec)||(ti.pic_width&hdec)
||(ti.pic_y&vdec)||(ti.pic_height&vdec)){
fprintf(stderr,
"Error: Cropped images with odd offsets/sizes and chroma subsampling\n"
"cannot be output to YUV4MPEG2. Remove the --crop flag or add the\n"
"--raw flag.\n");
exit(1);
}
width=ti.pic_width;
height=ti.pic_height;
}
else{
width=ti.frame_width;
height=ti.frame_height;
}
fprintf(outfile,"YUV4MPEG2 C%s W%d H%d F%d:%d I%c A%d:%d\n",
CHROMA_TYPES[ti.pixel_fmt],width,height,
ti.fps_numerator,ti.fps_denominator,'p',
ti.aspect_numerator,ti.aspect_denominator);
}
/* install signal handler */
signal (SIGINT, sigint_handler);
/*Finally the main decode loop.
It's one Theora packet per frame, so this is pretty straightforward if
we're not trying to maintain sync with other multiplexed streams.
The videobuf_ready flag is used to maintain the input buffer in the libogg
stream state.
If there's no output frame available at the end of the decode step, we must
need more input data.
We could simplify this by just using the return code on
ogg_page_packetout(), but the flag system extends easily to the case where
you care about more than one multiplexed stream (like with audio
playback).
In that case, just maintain a flag for each decoder you care about, and
pull data when any one of them stalls.
videobuf_time holds the presentation time of the currently buffered video
frame.
We ignore this value.*/
stateflag=0; /* playback has not begun */
/* queue any remaining pages from data we buffered but that did not
contain headers */
while(ogg_sync_pageout(&oy,&og)>0){
queue_page(&og);
}
if(fps_only){
ftime(&start);
ftime(&last);
}
while(!got_sigint){
while(theora_p && !videobuf_ready){
/* theora is one in, one out... */
if(ogg_stream_packetout(&to,&op)>0){
if(th_decode_packetin(td,&op,&videobuf_granulepos)>=0){
videobuf_time=th_granule_time(td,videobuf_granulepos);
videobuf_ready=1;
frames++;
if(fps_only)
ftime(&after);
}
}else
break;
}
if(fps_only && (videobuf_ready || fps_only==2)){
long ms =
after.time*1000.+after.millitm-
(last.time*1000.+last.millitm);
if(ms>500 || fps_only==1 ||
(feof(infile) && !videobuf_ready)){
float file_fps = (float)ti.fps_numerator/ti.fps_denominator;
fps_only=2;
ms = after.time*1000.+after.millitm-
(start.time*1000.+start.millitm);
fprintf(stderr,"\rframe:%d rate:%.2fx ",
frames,
frames*1000./(ms*file_fps));
memcpy(&last,&after,sizeof(last));
}
}
if(!videobuf_ready && feof(infile))break;
if(!videobuf_ready){
/* no data yet for somebody. Grab another page */
buffer_data(infile,&oy);
while(ogg_sync_pageout(&oy,&og)>0){
queue_page(&og);
}
}
/* dumpvideo frame, and get new one */
else if(outfile)video_write();
videobuf_ready=0;
}
/* end of decoder loop -- close everything */
if(theora_p){
ogg_stream_clear(&to);
th_decode_free(td);
th_comment_clear(&tc);
th_info_clear(&ti);
}
ogg_sync_clear(&oy);
if(infile && infile!=stdin)fclose(infile);
if(outfile && outfile!=stdout)fclose(outfile);
fprintf(stderr, "\n\n%d frames\n", frames);
fprintf(stderr, "\nDone.\n");
return(0);
}
int main(int argc, char *argv[]) {
daala_packet dp;
ogg_packet op;
int long_option_index;
int c;
ogg_sync_state oy;
ogg_page og;
ogg_stream_state to;
daala_info di;
daala_comment dc;
daala_setup_info *ds;
daala_dec_ctx *dd;
daala_image img;
const char *optstring = "o:r";
struct option options [] = {
{ "output", required_argument, NULL, 'o' },
{ "raw", no_argument, NULL, 'r' }, /*Disable YUV4MPEG2 headers:*/
{ "version", no_argument, NULL, 0},
{ NULL, 0, NULL, 0 }
};
int frames = 0;
int pix_fmt = 1;
int daala_p = 0;
int daala_processing_headers = 0;
int stateflag = 0;
/* single frame video buffering */
int videobuf_ready = 0;
int raw = 0;
FILE *outfile = NULL;
ogg_int32_t pic_width = 0;
ogg_int32_t pic_height = 0;
ogg_int32_t fps_num = 0;
ogg_int32_t fps_denom = 0;
FILE *infile = stdin;
outfile = stdout;
dd = NULL;
ds = NULL;
daala_log_init();
#ifdef _WIN32 /* We need to set stdin/stdout to binary mode on windows. */
/* Beware the evil ifdef. We avoid these where we can, but this one we
cannot. Don't add any more, you'll probably go to hell if you do. */
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
#endif
/* Process option arguments. */
while ((c = getopt_long(argc, argv, optstring, options, &long_option_index))
!= EOF) {
switch (c) {
case 'o': {
if (strcmp(optarg, "-") != 0) {
outfile = fopen(optarg, "wb");
if (outfile == NULL) {
fprintf(stderr, "Unable to open output file '%s'\n", optarg);
exit(1);
}
}
else {
outfile = stdout;
}
break;
}
case 'r': {
raw = 1;
break;
}
case 0: {
if (strcmp(options[long_option_index].name, "version") == 0) {
version();
}
break;
}
default: usage(); break;
}
}
if (optind < argc) {
infile = fopen(argv[optind], "rb");
if (infile == NULL) {
fprintf(stderr, "Unable to open '%s' for extraction.\n", argv[optind]);
exit(1);
}
if (++optind < argc) {
usage();
exit(1);
}
}
/*Ok, Ogg parsing.
The idea here is we have a bitstream that is made up of Ogg pages.
The libogg sync layer will find them for us.
There may be pages from several logical streams interleaved; we find the
first daala stream and ignore any others.
Then we pass the pages for our stream to the libogg stream layer which
assembles our original set of packets out of them.
start up Ogg stream synchronization layer */
ogg_sync_init(&oy);
/* init supporting Theora structures needed in header parsing */
daala_comment_init(&dc);
daala_info_init(&di);
/*Ogg file open; parse the headers.
Theora (like Vorbis) depends on some initial header packets for decoder
setup and initialization.
We retrieve these first before entering the main decode loop.*/
/* Only interested in Daala streams */
while (!stateflag) {
int ret = buffer_data(infile, &oy);
if (ret == 0) break;
while (ogg_sync_pageout(&oy, &og) > 0) {
int got_packet;
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, &to, daala_p);
stateflag = 1;
break;
}
ogg_stream_init(&test, ogg_page_serialno(&og));
ogg_stream_pagein(&test, &og);
got_packet = ogg_stream_packetpeek(&test, &op);
ogg_to_daala_packet(&dp, &op);
/* identify the codec: try daala */
if ((got_packet == 1) && !daala_p && (daala_processing_headers =
daala_decode_header_in(&di, &dc, &ds, &dp)) >= 0) {
/* it is daala -- save this stream state */
memcpy(&to, &test, sizeof(test));
daala_p = 1;
/*Advance past the successfully processed header.*/
if (daala_processing_headers) ogg_stream_packetout(&to, NULL);
}
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 (daala_p && daala_processing_headers) {
int ret;
/* look for further daala headers */
while (daala_processing_headers &&
(ret = ogg_stream_packetpeek(&to, &op))) {
if (ret < 0) continue;
ogg_to_daala_packet(&dp, &op);
daala_processing_headers = daala_decode_header_in(&di, &dc, &ds, &dp);
if (daala_processing_headers < 0) {
fprintf(stderr, "Error parsing Daala stream headers; "
"corrupt stream?\n");
exit(1);
}
else if (daala_processing_headers >= 0) {
/*Advance past the successfully processed header.*/
ogg_stream_packetout(&to, NULL);
}
daala_p++;
}
/*Stop now so we don't fail if there aren't enough pages in a short
stream.*/
if (!(daala_p && daala_processing_headers)) 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, &to, daala_p); /* demux into the appropriate stream */
}
else {
if (buffer_data(infile, &oy) == 0) { /* someone needs more data */
fprintf(stderr, "End of file while searching for codec headers.\n");
exit(1);
}
}
}
/* and now we have it all. initialize decoders */
if (daala_p) {
dump_comments(&dc);
dd = daala_decode_create(&di, ds);
fprintf(stderr, "Ogg logical stream %lx is Daala %dx%d %.02f fps video\n",
to.serialno, di.pic_width, di.pic_height,
di.timebase_numerator/(double)di.timebase_denominator*di.frame_duration);
}
else {
/* tear down the partial daala setup */
daala_info_clear(&di);
daala_comment_clear(&dc);
}
/*Either way, we're done with the codec setup data.*/
daala_setup_free(ds);
if (!raw && outfile) {
static const char *CHROMA_TYPES[5] = {
"420jpeg", NULL, "422jpeg", "444", "mono"
};
pic_width = di.pic_width;
pic_height = di.pic_height;
fps_num = di.timebase_numerator;
fps_denom = di.timebase_denominator*di.frame_duration;
if (di.nplanes > 1) {
/*calculate pixel_fmt based on the xdec & ydec values from one of the
chroma planes.*/
if (di.plane_info[1].xdec == 1 && di.plane_info[1].ydec == 1) {
pix_fmt = 0;
}
else if (di.plane_info[1].xdec == 1 && di.plane_info[1].ydec == 0) {
pix_fmt = 2;
}
else if (di.plane_info[1].xdec == 0 && di.plane_info[1].ydec == 0) {
pix_fmt = 3;
}
}
else {
pix_fmt = 4;
}
if (pix_fmt >= 5 || pix_fmt == 1) {
fprintf(stderr, "Unknown pixel format: %i\n", pix_fmt);
exit(1);
}
/*Store header information*/
fprintf(outfile, "YUV4MPEG2 W%d H%d F%d:%d Ip A%d:%d C%s\n",
pic_width, pic_height, fps_num, fps_denom,
di.pixel_aspect_numerator, di.pixel_aspect_denominator,
CHROMA_TYPES[pix_fmt]);
}
/* install signal handler */
signal(SIGINT, sigint_handler);
/*Finally the main decode loop.
It's one Daala packet per frame, so this is pretty straightforward if
we're not trying to maintain sync with other multiplexed streams.
The videobuf_ready flag is used to maintain the input buffer in the libogg
stream state.
If there's no output frame available at the end of the decode step, we must
need more input data.
We could simplify this by just using the return code on
ogg_page_packetout(), but the flag system extends easily to the case where
you care about more than one multiplexed stream (like with audio
playback).
In that case, just maintain a flag for each decoder you care about, and
pull data when any one of them stalls.*/
stateflag = 0; /* playback has not begun */
/* queue any remaining pages from data we buffered but that did not
contain headers */
while (ogg_sync_pageout(&oy, &og) > 0) {
queue_page(&og, &to, daala_p);
}
while (!got_sigint) {
while (daala_p && !videobuf_ready) {
if (ogg_stream_packetout(&to, &op) > 0) {
ogg_to_daala_packet(&dp, &op);
if (daala_decode_packet_in(dd, &dp) >= 0) {
videobuf_ready = 1;
frames++;
}
}
else break;
}
if (!videobuf_ready && feof(infile)) break;
if (!videobuf_ready) {
/* no data yet for somebody. Grab another page */
buffer_data(infile, &oy);
while (ogg_sync_pageout(&oy, &og) > 0) {
queue_page(&og, &to, daala_p);
}
}
/* dumpvideo frame, and get new one */
else if (outfile && daala_decode_img_out(dd, &img)) {
video_write(outfile, &img, raw);
}
videobuf_ready = 0;
}
/*Flush the output frame buffer of decoder.*/
while (!got_sigint && daala_decode_img_out(dd, &img)) {
video_write(outfile, &img, raw);
}
/* end of decoder loop -- close everything */
if (daala_p) {
ogg_stream_clear(&to);
daala_decode_free(dd);
daala_comment_clear(&dc);
daala_info_clear(&di);
}
ogg_sync_clear(&oy);
if (infile && infile != stdin) fclose(infile);
if (outfile && outfile != stdout) fclose(outfile);
fprintf(stderr, "\n\n%d frames\n", frames);
fprintf(stderr, "\nDone.\n");
return 0;
}
int main( int argc, char* argv[] ){
int i,j;
ogg_packet op;
SDL_Event event;
int hasdatatobuffer = 1;
int playbackdone = 0;
double now, delay, last_frame_time = 0;
int frameNum=0;
int skipNum=0;
/* takes first argument as file to play */
/* this works better on Windows and is more convenient
for drag and drop ogg files over the .exe */
if( argc != 2 )
{
usage();
exit(0);
}
infile = fopen( argv[1], "rb" );
/* 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 */
theora_comment_init(&tc);
theora_info_init(&ti);
parseHeaders();
/* force audio off */
/* vorbis_p = 0; */
/* initialize decoders */
if(theora_p){
theora_decode_init(&td,&ti);
printf("Ogg logical stream %x is Theora %dx%d %.02f fps video\n"
" Frame content is %dx%d with offset (%d,%d).\n",
to.serialno,ti.width,ti.height, (double)ti.fps_numerator/ti.fps_denominator,
ti.frame_width, ti.frame_height, ti.offset_x, ti.offset_y);
report_colorspace(&ti);
dump_comments(&tc);
}else{
/* tear down the partial theora setup */
theora_info_clear(&ti);
theora_comment_clear(&tc);
}
if(vorbis_p){
vorbis_synthesis_init(&vd,&vi);
vorbis_block_init(&vd,&vb);
printf("Ogg logical stream %x is Vorbis %d channel %d 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();
/* our main loop */
while(!playbackdone){
/* break out on SDL quit event */
if ( SDL_PollEvent ( &event ) )
{
if ( event.type == SDL_QUIT ) break ;
}
/* get some audio data */
while(vorbis_p && !audiobuf_ready){
int ret;
float **pcm;
int count = 0;
int maxBytesToWrite;
/* is there pending audio? does it fit our circular buffer without blocking? */
ret=vorbis_synthesis_pcmout(&vd,&pcm);
maxBytesToWrite = GetAudioStreamWriteable(aOutStream);
if (maxBytesToWrite<=FRAMES_PER_BUFFER){
/* break out until there is a significant amount of
data to avoid a series of small write operations. */
break;
}
/* if there's pending, decoded audio, grab it */
if((ret>0)&&(maxBytesToWrite>0)){
for(i=0;i<ret && i<(maxBytesToWrite/vi.channels);i++)
for(j=0;j<vi.channels;j++){
int val=(int)(pcm[j][i]*32767.f);
if(val>32767)val=32767;
if(val<-32768)val=-32768;
samples[count]=val;
count++;
}
if(WriteAudioStream( aOutStream, samples, i )) {
if(count==maxBytesToWrite){
audiobuf_ready=1;
}
}
vorbis_synthesis_read(&vd,i);
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;
}
} /* end audio cycle */
while(theora_p && !videobuf_ready){
/* get one video packet... */
if(ogg_stream_packetout(&to,&op)>0){
theora_decode_packetin(&td,&op);
videobuf_granulepos=td.granulepos;
videobuf_time=theora_granule_time(&td,videobuf_granulepos);
/* update the frame counter */
frameNum++;
/* check if this frame time has not passed yet.
If the frame is late we need to decode additonal
ones and keep looping, since theora at this stage
needs to decode all frames */
now=get_time();
delay=videobuf_time-now;
if(delay>=0.0){
/* got a good frame, not late, ready to break out */
videobuf_ready=1;
}else if(now-last_frame_time>=1.0){
/* display at least one frame per second, regardless */
videobuf_ready=1;
}else{
fprintf(stderr, "dropping frame %d (%.3fs behind)\n",
frameNum, -delay);
}
}else{
/* need more data */
break;
}
}
if(!hasdatatobuffer && !videobuf_ready && !audiobuf_ready){
isPlaying = 0;
playbackdone = 1;
}
/* if we're set for the next frame, sleep */
if((!theora_p || videobuf_ready) &&
(!vorbis_p || audiobuf_ready)){
int ticks = 1.0e3*(videobuf_time-get_time());
if(ticks>0)
SDL_Delay(ticks);
}
if(videobuf_ready){
/* time to write our cached frame */
video_write();
videobuf_ready=0;
last_frame_time=get_time();
/* if audio has not started (first frame) then start it */
if ((!isPlaying)&&(vorbis_p)){
start_audio();
isPlaying = 1;
}
}
/* HACK: always look for more audio data */
audiobuf_ready=0;
/* buffer compressed data every loop */
if(hasdatatobuffer){
hasdatatobuffer=buffer_data(&oy);
if(hasdatatobuffer==0){
printf("Ogg buffering stopped, end of file reached.\n");
}
}
if (ogg_sync_pageout(&oy,&og)>0){
queue_page(&og);
}
} /* playbackdone */
/* show number of video frames decoded */
printf( "\n");
printf( "Frames decoded: %d", frameNum );
if(skipNum)
printf( " (only %d shown)", frameNum-skipNum);
printf( "\n" );
/* tear it all down */
fclose( infile );
if(vorbis_p){
audio_close();
ogg_stream_clear(&vo);
vorbis_block_clear(&vb);
vorbis_dsp_clear(&vd);
vorbis_comment_clear(&vc);
vorbis_info_clear(&vi);
}
if(theora_p){
ogg_stream_clear(&to);
theora_clear(&td);
theora_comment_clear(&tc);
theora_info_clear(&ti);
}
ogg_sync_clear(&oy);
printf("\r "
"\nDone.\n");
SDL_Quit();
return(0);
}
