steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/nsv/nsvplay/nsvdecode.cpp

999 lines
24 KiB
C++
Raw Blame History

#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;
}
Reference in New Issue View Git Blame Copy Permalink