//=============================================================================
//
// File : KviOggTheoraDecoder.cpp
// Creation date : Sat Nov 21 2009 22:53:21 CEST by Fabio Bas
//
// This file is part of the KVIrc IRC client distribution
// Copyright (C) 2009 Fabio Bas (ctrlaltca at libero dot it)
//
// This program is FREE software. You can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the HOPE that it will be USEFUL,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, write to the Free Software Foundation,
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// Based on the example encoder/player from Xiph.Org Foundation:
//=============================================================================
//
// function: example encoder application; makes an Ogg Theora/Vorbis
// file from YUV4MPEG2 and WAV input
// last mod: $Id: encoder_example.c 16517 2009-08-25 19:48:57Z giles $
//
//
// function: example SDL player application; plays Ogg Theora files (with
// optional Vorbis audio second stream)
// last mod: $Id: player_example.c 16628 2009-10-10 05:50:52Z gmaxwell $
//
#ifndef COMPILE_DISABLE_OGG_THEORA
#include <string.h>
#include <sys/time.h>
#include "KviMemory.h"
#include "KviOggTheoraDecoder.h"
#include "KviOggIrcText.h"
#include "KviDataBuffer.h"
using namespace KviOggIrcText;
#define OC_CLAMP255(_x) ((unsigned char)((((_x) < 0) - 1) & ((_x) | -((_x) > 255))))
KviOggTheoraDecoder::KviOggTheoraDecoder(KviDataBuffer * videoSignal, KviDataBuffer * textSignal)
{
m_pVideoSignal = videoSignal;
m_pTextSignal = textSignal;
theora_p = 0;
stateflag = 0;
ts = nullptr;
thda = false;
thtic = false;
irct_p = 0;
/* single frame video buffering */
videobuf_ready = 0;
videobuf_granulepos = -1;
videobuf_time = 0;
/* 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);
for(int i = 0; i < 256; i++)
{
lu_Y[i] = 2441889 * (i - 16) + 1048576;
lu_R[i] = 3347111 * (i - 128);
lu_GV[i] = -1704917 * (i - 128);
lu_GU[i] = -821585 * (i - 128);
lu_B[i] = 4230442 * (i - 128);
}
}
KviOggTheoraDecoder::~KviOggTheoraDecoder()
{
if(theora_p)
{
ogg_stream_clear(&to);
th_decode_free(td);
th_comment_clear(&tc);
th_info_clear(&ti);
}
if(irct_p)
{
ogg_stream_clear(&zo);
irct_encode_clear();
}
ogg_sync_clear(&oy);
}
void KviOggTheoraDecoder::addData(KviDataBuffer * stream)
{
//qDebug("adddata signal %p stream size %d",m_pVideoSignal, stream->size() );
if(stream->size() == 0)
return;
/* Ogg file open; parse the headers */
if(!stateflag)
{
char * buffer = ogg_sync_buffer(&oy, stream->size());
memcpy(buffer, stream->data(), stream->size());
ogg_sync_wrote(&oy, stream->size());
stream->clear();
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 */
//qDebug("queue_page && return");
queue_page(&og);
stateflag = 1;
return;
}
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)
{
qDebug("is theora, ts=%p &ts=%p", ts, &ts);
/* it is theora */
memcpy(&to, &test, sizeof(test));
theora_p = 1;
}
else if(!irct_p && irct_decode_headerin(&op) >= 0)
{
qDebug("is irct");
/* it is irct */
memcpy(&zo, &test, sizeof(test));
irct_p = 1;
}
else
{
//qDebug("is other");
/* whatever it is, we don't care about it */
ogg_stream_clear(&test);
}
}
/* fall through to non-bos page parsing */
}
//qDebug("checkpoint 2, theora_p=%d ",theora_p);
/* we're expecting more header packets. */
if((theora_p && theora_p < 3))
{
int ret;
/* look for further theora headers */
while(theora_p && (theora_p < 3) && (ret = ogg_stream_packetout(&to, &op)))
{
if(ret < 0)
{
qDebug("Error parsing Theora stream headers; corrupt stream?");
return;
}
if(!th_decode_headerin(&ti, &tc, &ts, &op))
{
qDebug("Error parsing Theora stream headers; corrupt stream?");
return;
}
theora_p++;
}
/* 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)
{
qDebug("queue_page");
queue_page(&og); /* demux into the appropriate stream */
}
else
{
qDebug("TheoraDecoder: need more data!");
//need more data
return;
}
}
//qDebug("checkpoint 3");
/* and now we have it all. initialize decoders */
if(theora_p && !thda)
{
thda = true;
td = th_decode_alloc(&ti, ts);
qDebug("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);
geometry.pic_w = ti.pic_width;
geometry.pic_h = ti.pic_height;
geometry.frame_w = ti.frame_width;
geometry.frame_h = ti.frame_height;
geometry.pic_x = ti.pic_x;
geometry.pic_y = ti.pic_y;
px_fmt = ti.pixel_fmt;
switch(ti.pixel_fmt)
{
case TH_PF_444:
qDebug(" 4:4:4 video");
break;
default:
qDebug(" video (UNSUPPORTED Chroma sampling!)");
return;
break;
}
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 w = ((ti.pic_x + ti.pic_width + 1) & ~1) - (ti.pic_x & ~1);
int h = ((ti.pic_y + ti.pic_height + 1) & ~1) - (ti.pic_y & ~1);
RGBbuffer = (unsigned char *)calloc(sizeof(char), w * h * 4);
}
else if(!thtic)
{
thtic = true;
/* tear down the partial theora setup */
th_info_clear(&ti);
th_comment_clear(&tc);
th_setup_free(ts);
}
// stateflag=0; /* playback has not begun */
if(irct_p)
{
if(ogg_stream_packetout(&zo, &op) > 0)
{
char * textPkt = nullptr;
int textSize = 0;
if(irct_decode_packetin(&textPkt, &textSize, &op) == 0)
{
m_pTextSignal->append((unsigned char *)textPkt, textSize);
}
}
}
if(theora_p && !videobuf_ready)
{
if(stream->size() > 0)
{
char * buffer = ogg_sync_buffer(&oy, stream->size());
memcpy(buffer, stream->data(), stream->size());
ogg_sync_wrote(&oy, stream->size());
stream->clear();
while(ogg_sync_pageout(&oy, &og) > 0)
queue_page(&og);
}
//qDebug("loop4 theora_p=%d videobuf_ready=%d",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_ready = 1;
}
else
{
//qDebug("ogg_stream_packetout <=0");
//need more data :)
return;
}
}
if(!videobuf_ready)
return;
if(stateflag && videobuf_ready)
{
video_write();
videobuf_ready = 0;
}
// if our buffers either don't exist or are ready to go,we can begin playback
if(!theora_p || videobuf_ready)
stateflag = 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 */
int KviOggTheoraDecoder::queue_page(ogg_page * page)
{
if(theora_p)
ogg_stream_pagein(&to, page);
if(irct_p)
ogg_stream_pagein(&zo, page);
return 0;
}
void KviOggTheoraDecoder::video_write(void)
{
th_ycbcr_buffer yuv;
int y_offset;
th_decode_ycbcr_out(td, yuv);
y_offset = (geometry.pic_x & ~1) + yuv[0].stride * (geometry.pic_y & ~1);
for(int i = 0; i < geometry.pic_h; i++)
{
unsigned char * in_y = (unsigned char *)yuv[0].data + y_offset + yuv[0].stride * i;
unsigned char * in_u = (unsigned char *)yuv[1].data + y_offset + yuv[1].stride * i;
unsigned char * in_v = (unsigned char *)yuv[2].data + y_offset + yuv[2].stride * i;
unsigned char * out = RGBbuffer + (geometry.pic_w * i * ARGB32_BPP);
for(int j = 0; j < geometry.pic_w; j++)
{
int r, g, b;
int y = lu_Y[in_y[j]];
b = (y + lu_B[in_u[j]]) >> 21;
out[j * 4] = OC_CLAMP255(b);
g = (y + lu_GV[in_v[j]] + lu_GU[in_u[j]]) >> 21;
out[j * 4 + 1] = OC_CLAMP255(g);
r = (y + lu_R[in_v[j]]) >> 21;
out[j * 4 + 2] = OC_CLAMP255(r);
out[j * 4 + 3] = 255; //alpha
}
}
int size = sizeof(char) * geometry.pic_w * geometry.pic_h * ARGB32_BPP;
//qDebug("VIDEO WRITE size=%d",size);
m_pVideoSignal->clear();
m_pVideoSignal->append(RGBbuffer, size);
}
#endif // COMPILE_DISABLE_OGG_THEORA
