999 lines
24 KiB
C++
999 lines
24 KiB
C++
#include <bfc/platform/platform.h>
|
|
#include <bfc/platform/strcmp.h>
|
|
#include <stdio.h>
|
|
#include <locale.h>
|
|
#include "audiostub.h"
|
|
#include "api.h"
|
|
#include "main.h"
|
|
#include "subtitles.h"
|
|
#include "../in_nsv/resource.h"
|
|
|
|
extern int config_subtitles;
|
|
#ifdef __APPLE__
|
|
#include <sys/time.h>
|
|
#include <unistd.h>
|
|
uint32_t GetTickCount()
|
|
{
|
|
struct timeval newtime;
|
|
|
|
gettimeofday(&newtime, 0);
|
|
return newtime.tv_sec*1000 + newtime.tv_usec/1000;
|
|
}
|
|
|
|
int MulDiv(int a, int b, int d)
|
|
{
|
|
return int ((int64_t)a * (int64_t)b) / (int64_t)d;
|
|
}
|
|
#endif
|
|
class NullAudioOutput : public IAudioOutput
|
|
{
|
|
public:
|
|
NullAudioOutput() { m_pause=0; m_pause_t=0; m_start_t=GetTickCount64(); }
|
|
~NullAudioOutput(){}
|
|
int canwrite() { return m_pause ? 0 : 65536; } // returns bytes writeable
|
|
void write(void *buf, int len) { }
|
|
ULONGLONG getpos() { return m_pause?m_pause_t:(GetTickCount64()-m_start_t); }
|
|
int isplaying(void) { return -1; }
|
|
ULONGLONG getwritepos() { return getpos(); }
|
|
void flush(unsigned int newtime)
|
|
{
|
|
if (m_pause) m_pause_t=newtime;
|
|
else m_start_t = GetTickCount64()-newtime;
|
|
}
|
|
void pause(int pause)
|
|
{
|
|
if (pause && !m_pause)
|
|
{
|
|
m_pause_t=GetTickCount64()-m_start_t;
|
|
m_pause=1;
|
|
}
|
|
else if (!pause && m_pause)
|
|
{
|
|
m_start_t = GetTickCount64()-m_pause_t;
|
|
m_pause=0;
|
|
m_pause_t=0;
|
|
}
|
|
}
|
|
|
|
private:
|
|
int m_pause;
|
|
ULONGLONG m_pause_t;
|
|
ULONGLONG m_start_t;
|
|
};
|
|
|
|
void NSVDecoder::pause(int pause)
|
|
{
|
|
if (aud_output) aud_output->pause(pause);
|
|
m_paused=pause;
|
|
}
|
|
|
|
ULONGLONG NSVDecoder::getpos()
|
|
{
|
|
return aud_output ? aud_output->getpos() : 0;
|
|
}
|
|
|
|
unsigned int NSVDecoder::getlen()
|
|
{
|
|
if (!fileheader.header_size || fileheader.file_lenms == 0xFFFFFFFF)
|
|
{
|
|
if (!file_reader || !avg_framesize_cnt || !avg_framesize_tot) return 0xFFFFFFFF;
|
|
int s=(int)file_reader->getsize();
|
|
if (s == 0xFFFFFFFF) return 0xFFFFFFFF;
|
|
|
|
int bytespersec=(int)((double)avg_framesize_tot/(double)avg_framesize_cnt*getFrameRate());
|
|
|
|
if (!bytespersec) return 0xFFFFFFFF;
|
|
return MulDiv(s,1000,bytespersec);
|
|
}
|
|
return fileheader.file_lenms;
|
|
}
|
|
|
|
void NSVDecoder::seek(unsigned int newpos)
|
|
{
|
|
m_need_seek=newpos;
|
|
m_again=0;
|
|
}
|
|
|
|
int NSVDecoder::canseek()
|
|
{
|
|
return file_reader ? file_reader->canseek() : 0;
|
|
}
|
|
|
|
char *NSVDecoder::getStatus()
|
|
{
|
|
if (m_prebuffer) return "Buffering";
|
|
return NULL;
|
|
}
|
|
|
|
void NSVDecoder::SetBuffering(int total_ms, int initial_ms, int after_underrun)
|
|
{
|
|
if (m_prebuffer) m_prebuffer=initial_ms;
|
|
m_pb_init=initial_ms;
|
|
m_pb_init_ur=after_underrun;
|
|
m_buffer_total=total_ms;
|
|
}
|
|
|
|
|
|
int64_t pdReadResolution(void)
|
|
{
|
|
int64_t myfeq;
|
|
#ifdef _WIN32
|
|
LARGE_INTEGER feq;
|
|
|
|
QueryPerformanceFrequency( &feq);
|
|
myfeq = feq.QuadPart;
|
|
#else
|
|
myfeq = 1000000;
|
|
#endif
|
|
|
|
return myfeq;
|
|
}
|
|
|
|
int64_t pdReadTimer(void)
|
|
{
|
|
int64_t mynow;
|
|
|
|
#ifdef _WIN32
|
|
LARGE_INTEGER now;
|
|
|
|
QueryPerformanceCounter( &now );
|
|
mynow = now.QuadPart;
|
|
#else
|
|
struct timeval newtime;
|
|
|
|
gettimeofday(&newtime,NULL);
|
|
mynow = (newtime.tv_sec * 1000000) + newtime.tv_usec ;
|
|
#endif
|
|
|
|
return mynow;
|
|
}
|
|
|
|
NSVDecoder::NSVDecoder(const char *url, IVideoOutput *output, char *subtitleurl)
|
|
{
|
|
m_precise_seeking=1;
|
|
pcm_samplerate=0;
|
|
seek_dumpframes=0;
|
|
seek_dumpaudiosamples=0;
|
|
m_avresync_time=0;
|
|
nsvbitstream_search=0;
|
|
m_paused=0;
|
|
m_bufstate=0;
|
|
hack_l_curpos=-1;
|
|
hack_l_curpos_ot=0;
|
|
vid_decoder_isnotnull=1;
|
|
aud_decoder_isnotnull=1;
|
|
video_frames_avail=0;
|
|
audio_frames_avail=0;
|
|
m_buffer_total=1000; // bufferahead
|
|
m_pb_init=m_prebuffer=1500; // initial prebuffer
|
|
m_pb_init_ur=1500; // after underrun
|
|
m_buf_memlimit=32*1024*1024;
|
|
m_pan=0;
|
|
m_volume=192;
|
|
m_title=0;
|
|
m_audio_type[0]=m_video_type[0]=0;
|
|
m_out_opened=0;
|
|
m_out=output;
|
|
vidout_ready=0;
|
|
vidout=0;
|
|
vidout_type=0;
|
|
vidout_time=0;
|
|
vidout_codec_width=0;
|
|
vidout_codec_height=0;
|
|
m_url=_strdup(url);
|
|
m_need_seek=~0;
|
|
needkf=1;
|
|
aspect=1.0;
|
|
framerate_override=0.0;
|
|
use_framerate_override=0;
|
|
vid_decoder=NULL;
|
|
aud_decoder=NULL;
|
|
aud_output=NULL;
|
|
framecnt=0;
|
|
hdrsearched=0;
|
|
file_reader=CreateReader(url);
|
|
if (!file_reader) m_err="Error opening input";
|
|
else m_err=NULL;
|
|
|
|
m_enable_subtitles=1;
|
|
m_subs_fontsize=0;
|
|
m_cur_subtitle=0;
|
|
if (subtitleurl && *subtitleurl) insertSubtitlesItem("From subtitle file",subtitleurl);
|
|
|
|
memset(&fileheader,0,sizeof(fileheader));
|
|
|
|
avg_framesize_tot=0;
|
|
avg_framesize_cnt=0;
|
|
avg_framesize_tot_v=0;
|
|
avg_framesize_cnt_v=0;
|
|
avg_framesize_tot_a=0;
|
|
avg_framesize_cnt_a=0;
|
|
|
|
unpacket.setAudioOut(&audiobs);
|
|
unpacket.setVideoOut(&videobs);
|
|
unpacket.setAuxOut(&auxbs);
|
|
|
|
proTimerStart = 1;
|
|
proTimerEnd = 0;
|
|
profiletime = 0.00;
|
|
prostart = 0.00;
|
|
proend = 0.00;
|
|
timeref = (float)pdReadResolution();
|
|
|
|
|
|
m_again = 0;
|
|
}
|
|
|
|
NSVDecoder::~NSVDecoder()
|
|
{
|
|
if (m_out_opened) m_out->close();
|
|
if (WASABI_API_MEMMGR)
|
|
WASABI_API_MEMMGR->Delete(vid_decoder);
|
|
else
|
|
delete vid_decoder;
|
|
if (WASABI_API_MEMMGR)
|
|
WASABI_API_MEMMGR->Delete(aud_decoder);
|
|
else
|
|
delete aud_decoder;
|
|
delete aud_output;
|
|
delete file_reader;
|
|
free(fileheader.metadata);
|
|
free(fileheader.toc);
|
|
free(m_url);
|
|
free(m_title);
|
|
}
|
|
|
|
char *NSVDecoder::get_error()
|
|
{
|
|
return m_err;
|
|
}
|
|
|
|
char *NSVDecoder::get_status()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
char *NSVDecoder::getFromMeta(char *name)
|
|
{
|
|
if (file_reader)
|
|
{
|
|
char *t=(char*)malloc(strlen(name)+8);
|
|
if (t)
|
|
{
|
|
strcpy(t,"x-nsv-");
|
|
strcat(t,name);
|
|
char *v=file_reader->getheader(t);
|
|
free(t);
|
|
if (v) return _strdup(v);
|
|
}
|
|
}
|
|
return nsv_getmetadata(fileheader.metadata,name);
|
|
}
|
|
|
|
|
|
unsigned int NSVDecoder::getFileSize()
|
|
{
|
|
if (file_reader) return (unsigned int)file_reader->getsize();
|
|
return ~0;
|
|
}
|
|
|
|
int NSVDecoder::getBitrate()
|
|
{
|
|
if (!fileheader.header_size || !fileheader.file_lenms || !fileheader.file_lenbytes ||
|
|
fileheader.file_lenms == 0xFFFFFFFF || fileheader.file_lenbytes == 0xFFFFFFFF)
|
|
{
|
|
if (!avg_framesize_cnt) return 0;
|
|
return (int) (8.0 * getFrameRate() * (double)avg_framesize_tot / (double)avg_framesize_cnt);
|
|
}
|
|
return MulDiv(fileheader.file_lenbytes,8000,fileheader.file_lenms);
|
|
}
|
|
|
|
const char *NSVDecoder::getServerHeader(char *name)
|
|
{
|
|
return file_reader?file_reader->getheader(name):NULL;
|
|
}
|
|
|
|
void NSVDecoder::getAudioDesc(char *buf)
|
|
{
|
|
char *t=getAudioType();
|
|
if (t && *t)
|
|
{
|
|
if (strcmp(t, "VLB")==0)
|
|
sprintf(buf,"Dolby AAC "); // special case; make sure the user never sees "VLB" name
|
|
else if (strcmp(t, "AACP")==0)
|
|
sprintf(buf,"HE-AAC ");
|
|
else if (strcmp(t, "AAC")==0)
|
|
sprintf(buf,"AAC LC ");
|
|
else
|
|
sprintf(buf,"%s ",t);
|
|
|
|
char *p=buf+strlen(buf);
|
|
if (aud_output) aud_output->getdescstr(p);
|
|
if (!*p) *--p=0;
|
|
|
|
int a=(getAudioBitrate()+500)/1000;
|
|
if (a) sprintf(buf+strlen(buf)," ~%d%s",a,WASABI_API_LNGSTRING(IDS_KBPS));
|
|
}
|
|
else *buf=0;
|
|
}
|
|
|
|
void NSVDecoder::getVideoDesc(char *buf)
|
|
{
|
|
char *t=getVideoType();
|
|
if (t && *t)
|
|
{
|
|
int fr=(int)(getFrameRate()*100.0);
|
|
sprintf(buf,"%s %dx%d@%d.%02d%s",t,getWidth(),getHeight(),fr/100,fr%100,WASABI_API_LNGSTRING(IDS_FPS));
|
|
|
|
int a=(getVideoBitrate()+500)/1000;
|
|
if (a) sprintf(buf+strlen(buf)," ~%d%s",a,WASABI_API_LNGSTRING(IDS_KBPS));
|
|
}
|
|
else *buf=0;
|
|
}
|
|
|
|
|
|
int NSVDecoder::getAudioBitrate()
|
|
{
|
|
if (!avg_framesize_cnt_a) return 0;
|
|
return (int) (8.0 * getFrameRate() * (double)avg_framesize_tot_a / (double)avg_framesize_cnt_a);
|
|
}
|
|
|
|
int NSVDecoder::getVideoBitrate()
|
|
{
|
|
if (!avg_framesize_cnt_v) return 0;
|
|
return (int) (8.0 * getFrameRate() * (double)avg_framesize_tot_v / (double)avg_framesize_cnt_v);
|
|
}
|
|
|
|
char *NSVDecoder::getTitle()
|
|
{
|
|
char *v=getFromMeta("TITLE");
|
|
if (v)
|
|
{
|
|
if (!m_title || strcmp(v,m_title))
|
|
{
|
|
free(m_title);
|
|
m_title=v;
|
|
}
|
|
else free(v);
|
|
return m_title;
|
|
}
|
|
if (file_reader)
|
|
{
|
|
v=file_reader->gettitle();
|
|
if (v) return v;
|
|
}
|
|
|
|
if (!m_url) return "";
|
|
|
|
v=m_url+strlen(m_url);
|
|
while (v >= m_url && *v != '/' && *v != '\\' && *v != '=') v--;
|
|
return ++v;
|
|
}
|
|
|
|
void NSVDecoder::ProcessSubtitleBlock(void *data, int len)
|
|
{
|
|
unsigned char *dataptr=(unsigned char *)data;
|
|
while (len > 2)
|
|
{
|
|
int len_block=(dataptr[0] | ((unsigned short)dataptr[1] << 8));
|
|
dataptr += 2;
|
|
len -= 2;
|
|
if (len_block > len) break;
|
|
|
|
SUBTITLE_INFO sti={0,};
|
|
sti.language = (char *)dataptr;
|
|
while (len_block > 0 && *dataptr)
|
|
{
|
|
dataptr++;
|
|
len_block--;
|
|
len--;
|
|
}
|
|
dataptr++;
|
|
len_block--;
|
|
len--;
|
|
if (len_block < 1) break;
|
|
sti.utf8_text = (char *)dataptr;
|
|
while (len_block > 0 && *dataptr)
|
|
{
|
|
dataptr++;
|
|
len_block--;
|
|
len--;
|
|
}
|
|
dataptr++;
|
|
len_block--;
|
|
len--;
|
|
if (len_block < 6) break;
|
|
|
|
sti.start_frame = framecnt + video_frames_avail + (dataptr[0] | ((int)dataptr[1] << 8));
|
|
dataptr+=2;
|
|
len-=2;
|
|
len_block-=2;
|
|
|
|
sti.end_frame = sti.start_frame + (dataptr[0] | ((int)dataptr[1] << 8) | ((int)dataptr[2] << 16) | ((int)dataptr[3] << 24));
|
|
dataptr+=4;
|
|
len-=4;
|
|
len_block-=4;
|
|
|
|
// set defaults for color/position
|
|
sti.xPos=128;
|
|
sti.yPos=255;
|
|
sti.colorRed=255;
|
|
sti.colorGreen=255;
|
|
sti.colorBlue=255;
|
|
sti.fontSize=0;
|
|
|
|
if (len_block >= 2)
|
|
{
|
|
sti.xPos = *dataptr++;
|
|
sti.yPos = *dataptr++;
|
|
len-=2;
|
|
len_block-=2;
|
|
if (len_block >= 3)
|
|
{
|
|
sti.colorRed=*dataptr++;
|
|
sti.colorGreen=*dataptr++;
|
|
sti.colorBlue=*dataptr++;
|
|
len-=3;
|
|
len_block-=3;
|
|
if (len_block > 0)
|
|
{
|
|
sti.fontSize=(signed char) *dataptr++;
|
|
len--;
|
|
len_block--;
|
|
}
|
|
|
|
if (len_block > 0)
|
|
{
|
|
sti.extraData=dataptr;
|
|
sti.extraDataSize=len_block;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
Subtitles *sub=findSubtitles(sti.language);
|
|
if(!sub) sub=insertSubtitlesItem(sti.language,NULL);
|
|
sub->addSubtitlePacket(&sti);
|
|
|
|
if (len_block > 0)
|
|
{
|
|
len-=len_block;
|
|
dataptr+=len_block;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
int NSVDecoder::run(int * volatile quit) // returns -1 on error, 0 if no frames processed, 1 if frames processed, 2 if underrun
|
|
{
|
|
int retval=0;
|
|
|
|
|
|
if (!file_reader) return -1;
|
|
|
|
if (!aud_decoder_isnotnull && !vid_decoder_isnotnull && vid_decoder && aud_decoder)
|
|
{
|
|
m_err="Codec(s) not found";
|
|
return -1;
|
|
}
|
|
|
|
if (aud_output && vidout_ready)
|
|
{
|
|
ULONGLONG curpos=aud_output->getpos();
|
|
if (!m_paused)
|
|
{
|
|
if (!audio_frames_avail && curpos == hack_l_curpos && unpacket.getEof())
|
|
{
|
|
hack_l_curpos=curpos;
|
|
curpos += GetTickCount64() - hack_l_curpos_ot;
|
|
}
|
|
else
|
|
{
|
|
hack_l_curpos_ot=GetTickCount64();
|
|
hack_l_curpos=curpos;
|
|
}
|
|
}
|
|
|
|
if (curpos >= vidout_time && !m_prebuffer)
|
|
{
|
|
if (vidout)
|
|
{
|
|
// send this to get the flip state updated so when toggled on-the-fly it will work with nsv
|
|
m_out->extended(0x1002/*VIDUSER_SET_VFLIP*/,vid_flip,0);
|
|
m_out->draw(vidout);
|
|
}
|
|
|
|
if (m_enable_subtitles)
|
|
{
|
|
SubtitlesItem *it=m_subtitles.get(m_cur_subtitle);
|
|
if(it && config_subtitles) {
|
|
it->m_subs->setFontSizeModifier(m_subs_fontsize);
|
|
m_out->drawSubtitle(it->m_subs->getSubtitle((unsigned int)aud_output->getpos(),framecnt));
|
|
}
|
|
if ( it && !config_subtitles )
|
|
{
|
|
m_out->drawSubtitle(NULL);
|
|
}
|
|
}
|
|
vidout=0;
|
|
vidout_ready=0;
|
|
}
|
|
}
|
|
|
|
if (hdrsearched && m_need_seek!=~0 && aud_output)
|
|
{
|
|
unsigned int newpos=m_need_seek;
|
|
m_need_seek=~0;
|
|
seek_dumpaudiosamples=0;
|
|
seek_dumpframes=0;
|
|
if (file_reader->canseek() && file_reader->getsize() != 0xFFFFFFFF)
|
|
{
|
|
int nbpos;
|
|
|
|
if (!fileheader.toc_size || !fileheader.toc || !fileheader.file_lenms ||
|
|
!fileheader.file_lenbytes ||
|
|
fileheader.file_lenms == 0xFFFFFFFF || fileheader.file_lenbytes == 0xFFFFFFFF)
|
|
{
|
|
int avg_framesize=avg_framesize_tot/avg_framesize_cnt;
|
|
int pos_frames=(int)(newpos*getFrameRate());
|
|
nbpos=fileheader.header_size+MulDiv(pos_frames,avg_framesize,1000);
|
|
}
|
|
else // calculate offset using TOC
|
|
{
|
|
if (fileheader.toc_ex) // use extended toc, find next earliest time closest
|
|
{
|
|
int x;
|
|
double scale;
|
|
if (unpacket.isValid() && getFrameRate() > 0.0001)
|
|
scale=1000.0 / getFrameRate();
|
|
else scale = 1000.0 / 30.0;
|
|
for (x = 0; x < (int)fileheader.toc_size; x ++)
|
|
{
|
|
if (newpos < (unsigned int) (fileheader.toc_ex[x]*scale)) break;
|
|
}
|
|
unsigned int hdr[2]={0,0};
|
|
if (--x >= 0)
|
|
{
|
|
hdr[0]=fileheader.toc[x];
|
|
hdr[1]=(unsigned int) (fileheader.toc_ex[x] * scale);
|
|
}
|
|
//hdr[1] is the time of that keyframe
|
|
|
|
if (m_precise_seeking) // precise seek
|
|
{
|
|
int timediff = newpos - hdr[1];
|
|
double fr;
|
|
if (unpacket.isValid() && getFrameRate() >= 0.0001) fr = getFrameRate() / 1000.0;
|
|
else fr = 30.0 / 1000.0;
|
|
|
|
seek_dumpframes=(int) (timediff * fr);
|
|
seek_dumpaudiosamples=MulDiv(timediff,pcm_samplerate,1000);
|
|
}
|
|
else
|
|
{
|
|
newpos=hdr[1];
|
|
}
|
|
|
|
nbpos = fileheader.header_size + hdr[0];
|
|
}
|
|
else
|
|
{
|
|
double tocpos=(newpos*(double)fileheader.toc_size)/(double)fileheader.file_lenms;
|
|
unsigned int tocidx=(unsigned int)tocpos;
|
|
if (tocidx > fileheader.toc_size)
|
|
{
|
|
nbpos=fileheader.header_size + fileheader.file_lenbytes;
|
|
}
|
|
else
|
|
{
|
|
unsigned int a,b;
|
|
if (tocidx<0) tocidx=0;
|
|
a = fileheader.toc[tocidx];
|
|
if (tocidx < fileheader.toc_size-1)
|
|
b = fileheader.toc[tocidx+1];
|
|
else b=fileheader.file_lenbytes;
|
|
double frac=tocpos-tocidx;
|
|
|
|
nbpos = fileheader.header_size + (int) (a * (1.0 - frac) + b * frac);
|
|
}
|
|
}
|
|
}
|
|
if (!file_reader->seek(nbpos))
|
|
{
|
|
framecnt=(int)(newpos*getFrameRate()/1000.0);
|
|
unpacket.reset(0);
|
|
unpacket.setEof(0);
|
|
hdrsearched=1;
|
|
needkf=1;
|
|
m_avresync_time=0;
|
|
vidout=0;
|
|
vidout_ready=0;
|
|
video_frames_avail=0;
|
|
audio_frames_avail=0;
|
|
m_prebuffer=m_pb_init;
|
|
inbs.clear();
|
|
audiobs.clear();
|
|
videobs.clear();
|
|
auxbs.clear();
|
|
if (aud_output) aud_output->flush(newpos);
|
|
if (aud_decoder) aud_decoder->flush();
|
|
if (vid_decoder) vid_decoder->flush();
|
|
}
|
|
}
|
|
} // end of seeking
|
|
|
|
if (!hdrsearched) // search for header
|
|
{
|
|
readagain_header:
|
|
if (quit && *quit) return 0;
|
|
int ret=nsv_readheader(inbs,&fileheader);
|
|
if (ret <= 0)
|
|
{
|
|
hdrsearched++;
|
|
if (!ret)
|
|
{
|
|
_locale_t C_locale = WASABI_API_LNG->Get_C_NumericLocale();
|
|
char *v=getFromMeta("ASPECT");
|
|
if (v)
|
|
{
|
|
aspect=_atof_l(v,C_locale);
|
|
}
|
|
free(v);
|
|
v=getFromMeta("FRAMERATE");
|
|
if (v)
|
|
{
|
|
framerate_override=_atof_l(v,C_locale);
|
|
if (framerate_override >= 0.01) use_framerate_override=1;
|
|
free(v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
char buf[8192] = {0};
|
|
size_t ret2=file_reader->read(buf,sizeof(buf));
|
|
|
|
if (file_reader->iseof()) unpacket.setEof(1);
|
|
|
|
if (file_reader->geterror())
|
|
{
|
|
m_err=file_reader->geterror();
|
|
return -1;
|
|
}
|
|
if (ret2>0)
|
|
{
|
|
inbs.add(buf, (int)ret2);
|
|
goto readagain_header;
|
|
}
|
|
}
|
|
}
|
|
if (!hdrsearched) return 0;
|
|
// end of header search
|
|
|
|
// read from source
|
|
if (m_prebuffer ||
|
|
(((!unpacket.isValid() || audio_frames_avail < (int)((getFrameRate() * m_buffer_total)/1000.0)) || !videobs.avail()) &&
|
|
(!m_buf_memlimit || ((int)(audiobs.avail()+videobs.avail()) < m_buf_memlimit*8))))
|
|
{
|
|
readagain_stream:
|
|
if (quit && *quit) return 0;
|
|
int lavail= (int)inbs.avail();
|
|
|
|
int ret=unpacket.unpacket(inbs);
|
|
|
|
inbs.compact();
|
|
|
|
if (ret)
|
|
{
|
|
if (!unpacket.isValid() && nsvbitstream_search > 8*1024*1024) // only scan for 8mb max
|
|
{
|
|
m_err="Error synching to NSV stream";
|
|
return -1;
|
|
}
|
|
if (unpacket.getEof())
|
|
{
|
|
if (!videobs.avail() && !video_frames_avail && (!aud_output || aud_output->isplaying() <= 0)) retval=-1;
|
|
// do nothing
|
|
}
|
|
else
|
|
{
|
|
char buf[8192] = {0};
|
|
|
|
size_t ret2=file_reader->read(buf,sizeof(buf));
|
|
|
|
if (ret2 == 0 && file_reader->iseof())
|
|
{
|
|
m_prebuffer=0;
|
|
unpacket.setEof(1);
|
|
}
|
|
|
|
if (file_reader->geterror())
|
|
{
|
|
m_err=file_reader->geterror();
|
|
return -1;
|
|
}
|
|
|
|
if (ret2 > 0)
|
|
{
|
|
nsvbitstream_search+= (int)ret2;
|
|
inbs.add(buf, (int)ret2);
|
|
goto readagain_stream;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nsvbitstream_search=0;
|
|
video_frames_avail++;
|
|
audio_frames_avail++;
|
|
nsv_type_to_string(unpacket.getAudFmt(),m_audio_type);
|
|
nsv_type_to_string(unpacket.getVidFmt(),m_video_type);
|
|
|
|
avg_framesize_cnt++;
|
|
avg_framesize_tot+=lavail- (int)((inbs.avail())/8);
|
|
if (avg_framesize_tot > 0x80000000)
|
|
{
|
|
avg_framesize_tot/=2;
|
|
avg_framesize_cnt/=2;
|
|
}
|
|
|
|
if (1)
|
|
{
|
|
//parse aux packets
|
|
while (auxbs.avail() >= 8*8)
|
|
{
|
|
size_t thislen = auxbs.getbits(32);
|
|
unsigned int thistype = auxbs.getbits(32);
|
|
if (thislen > auxbs.avail()/8) break;
|
|
|
|
if (thistype == NSV_MAKETYPE('S','U','B','T') ) ProcessSubtitleBlock(auxbs.getcurbyteptr(), (int)thislen);
|
|
else if (thistype == NSV_MAKETYPE('A','S','Y','N'))
|
|
{
|
|
//if (thislen == 0) // resyncpoint
|
|
{
|
|
audiobs.addint(-1);
|
|
audiobs.addint(framecnt+video_frames_avail);
|
|
}
|
|
//else // handle other form [todo]
|
|
//{
|
|
//}
|
|
}
|
|
|
|
auxbs.seek(thislen*8);
|
|
}
|
|
}
|
|
auxbs.clear();
|
|
}
|
|
}
|
|
|
|
if (unpacket.isValid() && !m_prebuffer && !audiobs.avail() && aud_output)
|
|
{
|
|
if (aud_output->isplaying()) aud_output->write(0,0);
|
|
else if (!unpacket.getEof())
|
|
{
|
|
m_prebuffer=m_pb_init_ur+(int)((video_frames_avail/getFrameRate())*1000.0);
|
|
if (m_prebuffer < m_pb_init_ur) m_prebuffer=m_pb_init_ur;
|
|
if (m_prebuffer > m_pb_init_ur*3) m_prebuffer=m_pb_init_ur*3;
|
|
retval=2;
|
|
}
|
|
}
|
|
|
|
if (video_frames_avail > (int)((m_prebuffer*getFrameRate())/1000.0))
|
|
{
|
|
m_bufstate=256;
|
|
m_prebuffer=0;
|
|
}
|
|
else
|
|
{
|
|
int a = (int) (video_frames_avail * 256.0 / ((m_prebuffer*getFrameRate())/1000.0));
|
|
if (a > 255) a=255;
|
|
if (a < 0) a=0;
|
|
m_bufstate=a;
|
|
if (m_out) m_out->notifyBufferState(a);
|
|
}
|
|
|
|
if (unpacket.isValid() && !vidout_ready && videobs.avail() && !m_prebuffer) // decode frame
|
|
{
|
|
if (!vid_decoder)
|
|
{
|
|
vid_flip=0;
|
|
vid_decoder = CreateVideoDecoder(unpacket.getWidth(),unpacket.getHeight(),
|
|
getFrameRate(),unpacket.getVidFmt(),&vid_flip,&vid_decoder_isnotnull);
|
|
}
|
|
|
|
int kf=0;
|
|
int l=videobs.getbits(32);
|
|
unsigned int local_vidout_type[3] = { 1, 0, 0 };
|
|
int ret=vid_decoder->decode(needkf,videobs.getcurbyteptr(),l,&vidout,local_vidout_type,&kf);
|
|
vidout_type = local_vidout_type[0];
|
|
if (ret == 0)
|
|
{
|
|
|
|
vidout_codec_width = local_vidout_type[1];
|
|
vidout_codec_height = local_vidout_type[2];
|
|
}
|
|
|
|
if (kf) needkf=0;
|
|
video_frames_avail--;
|
|
videobs.seek(l*8);
|
|
videobs.compact();
|
|
|
|
avg_framesize_cnt_v++;
|
|
avg_framesize_tot_v+=l;
|
|
|
|
if (needkf || seek_dumpframes > 0)
|
|
{
|
|
vidout=NULL;
|
|
if (seek_dumpframes>0) seek_dumpframes--;
|
|
}
|
|
else
|
|
{
|
|
if (!m_out_opened && vid_decoder_isnotnull)
|
|
{
|
|
m_out->extended(0x1008/*VIDUSER_SET_THREAD_SAFE*/, 1, 0);
|
|
unsigned int vidwidth = vidout_codec_width, vidheight = vidout_codec_height;
|
|
if (vidwidth && vidheight)
|
|
{
|
|
/* if the codec provided a width/height to use */
|
|
double aspect_adjust = (double)vidwidth / (double)vidheight / ((double)unpacket.getWidth() / (double)unpacket.getHeight());
|
|
if (m_out->open(vidwidth,vidheight,vid_flip,aspect * aspect_adjust,vidout_type))
|
|
{
|
|
m_err="Error opening video output";
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_out->open(unpacket.getWidth(),unpacket.getHeight(),vid_flip,aspect,vidout_type))
|
|
{
|
|
m_err="Error opening video output";
|
|
return -1;
|
|
}
|
|
}
|
|
m_out_opened=1;
|
|
}
|
|
|
|
vidout_ready=1;
|
|
vidout_time = (unsigned int)(framecnt++ / getFrameRate() * 1000.0) + (unsigned int)m_avresync_time;
|
|
int offs=unpacket.getSyncOffset() + m_out->get_latency();
|
|
|
|
if ((int)vidout_time <= offs) vidout_time=0;
|
|
else vidout_time-=offs;
|
|
|
|
//drop the image if we're late
|
|
if(aud_output && vidout_time<aud_output->getpos()) {
|
|
vidout=0;
|
|
vidout_ready=0;
|
|
}
|
|
}
|
|
|
|
retval=1;
|
|
}
|
|
|
|
if ( ( audiobs.avail() && !m_prebuffer ) || m_again )
|
|
{
|
|
if (needkf)
|
|
{
|
|
int l=audiobs.getbits(32);
|
|
if (l == -1) audiobs.seek(32); // skip over 32 bits of our audiobs info
|
|
else
|
|
{
|
|
audiobs.seek(l*8);
|
|
audio_frames_avail--;
|
|
}
|
|
|
|
audiobs.compact();
|
|
}
|
|
else // decode some audio
|
|
{
|
|
char pcmbuf[16384] = {0};
|
|
int outbufl=512;
|
|
if (!aud_decoder)
|
|
{
|
|
aud_decoder=CreateAudioDecoder(unpacket.getAudFmt(),&aud_decoder_isnotnull,&aud_output);
|
|
if (aud_output && m_paused) aud_output->pause(1);
|
|
}
|
|
|
|
if (aud_output) outbufl=aud_output->canwrite();
|
|
|
|
if (outbufl)
|
|
{
|
|
unsigned int outfmt[8] = {0};
|
|
|
|
retval=1;
|
|
if (outbufl > sizeof(pcmbuf)) outbufl=sizeof(pcmbuf);
|
|
|
|
int inl=audiobs.getbits(32);
|
|
|
|
if (inl == -1)
|
|
{
|
|
int vidframe=audiobs.getbits(32);
|
|
if (aud_output)
|
|
{
|
|
ULONGLONG audpos = aud_output->getwritepos();
|
|
int vidpos = (int)(vidframe / getFrameRate() * 1000.0);
|
|
|
|
m_avresync_time = audpos-vidpos;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int ret=aud_decoder->decode(audiobs.getcurbyteptr(), inl, pcmbuf, &outbufl, outfmt);
|
|
|
|
if ( !outbufl ) m_again = 0;
|
|
else m_again =1;
|
|
|
|
if (ret < 1)
|
|
{
|
|
avg_framesize_cnt_a++;
|
|
avg_framesize_tot_a+=inl;
|
|
audiobs.seek(inl*8);
|
|
audiobs.compact();
|
|
audio_frames_avail--;
|
|
}
|
|
else audiobs.seek(-32);
|
|
|
|
if (outbufl || outfmt[0])
|
|
{
|
|
if (!aud_output)
|
|
{
|
|
aud_output=PCMOUT_CREATE(outfmt);
|
|
pcm_samplerate=outfmt[1];
|
|
if (!aud_output) aud_output = new NullAudioOutput;
|
|
aud_output->setvolume(m_volume);
|
|
aud_output->setpan(m_pan);
|
|
if (aud_output && m_paused) aud_output->pause(1);
|
|
}
|
|
if (outbufl)
|
|
{
|
|
if (seek_dumpaudiosamples)
|
|
{
|
|
int nch=outfmt[2];
|
|
int bps=outfmt[3];
|
|
int dump=seek_dumpaudiosamples*nch*(bps/8);
|
|
if (dump >= outbufl)
|
|
{
|
|
seek_dumpaudiosamples -= outbufl/nch/(bps/8);
|
|
}
|
|
else // partial write
|
|
{
|
|
aud_output->write(pcmbuf+dump,outbufl-dump);
|
|
seek_dumpaudiosamples=0;
|
|
}
|
|
}
|
|
else aud_output->write(pcmbuf,outbufl);
|
|
}
|
|
}
|
|
}
|
|
} // if can write
|
|
} //end of decode
|
|
} // audiobs avail
|
|
|
|
if (m_prebuffer)
|
|
#ifdef _WIN32
|
|
Sleep(10);
|
|
#else
|
|
usleep(10000);
|
|
#endif
|
|
|
|
return retval;
|
|
}
|
|
|
|
Subtitles *NSVDecoder::insertSubtitlesItem(const char *language, const char *subfile) {
|
|
Subtitles *sub=new Subtitles(subfile);
|
|
m_subtitles.put(new SubtitlesItem(language, sub));
|
|
return sub;
|
|
}
|
|
|
|
Subtitles *NSVDecoder::findSubtitles(const char *language) {
|
|
for(int i=0;i<m_subtitles.getlen();i++) {
|
|
SubtitlesItem *s=m_subtitles.get(i);
|
|
if(!_stricmp(language,s->m_language) ) return s->m_subs;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const char *NSVDecoder::getSubLanguage(int index) {
|
|
if(index>=m_subtitles.getlen()) return NULL;
|
|
return m_subtitles.get(index)->m_language;
|
|
} |