steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Input/in_avi/VideoThread.cpp

429 lines
9.7 KiB
C++
Raw Permalink Blame History

#include "main.h"
#include "api__in_avi.h"
#include "../nu/AutoLock.h"
#include "../nu/SampleQueue.h"
#include "../Winamp/wa_ipc.h"
#include "interfaces.h"
#include "../nsavi/nsavi.h"
#include "../nu/ThreadName.h"
#include "player.h"
// {B6CB4A7C-A8D0-4c55-8E60-9F7A7A23DA0F}
static const GUID playbackConfigGroupGUID =
{ 0xb6cb4a7c, 0xa8d0, 0x4c55, { 0x8e, 0x60, 0x9f, 0x7a, 0x7a, 0x23, 0xda, 0xf } };
extern nsavi::HeaderList header_list;
extern int video_stream_num;
int width, height;
extern IVideoOutput *video_output;
static HANDLE video_thread=0;
extern ifc_avivideodecoder *video_decoder;
bool video_opened=false;
static HANDLE coded_frames_event=0;
static Nullsoft::Utility::LockGuard coded_frames_guard;
uint64_t video_total_time=0;
HANDLE video_break=0, video_flush=0, video_flush_done=0, video_resume=0, video_ready=0;
static int GetStreamNumber(uint32_t id)
{
char *stream_data = (char *)(&id);
if (!isxdigit(stream_data[0]) || !isxdigit(stream_data[1]))
return -1;
stream_data[2] = 0;
int stream_number = strtoul(stream_data, 0, 16);
return stream_number;
}
void Video_Init()
{
video_opened=false;
video_decoder=0;
video_thread=0;
width=0;
height=0;
video_total_time=0;
if (coded_frames_event == 0)
coded_frames_event = CreateEvent(NULL, FALSE, FALSE, NULL);
/* video events */
if (!video_break)
video_break = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!video_flush_done)
video_flush_done = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!video_flush)
video_flush = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!video_resume)
video_resume = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!video_ready)
video_ready = CreateEvent(NULL, TRUE, FALSE, NULL);
}
struct FRAMEDATA
{
FRAMEDATA()
{
type = 0;
data=0;
length=0;
}
~FRAMEDATA()
{
free(data);
}
void Reset()
{
free(data);
data=0;
length=0;
type = 0;
}
void Set(uint16_t _type, void *_data, size_t _length)
{
type = _type;
data = _data;
length = _length;
}
void *data;
size_t length;
uint16_t type;
};
static SampleQueue<FRAMEDATA> coded_frames;
extern int GetOutputTime();
struct VideoContext
{
nsavi::avi_reader *reader;
nsavi::Demuxer *demuxer;
int video_stream_num;
};
static void DecodeVideo(FRAMEDATA *frame_data)
{
HANDLE handles[] = {killswitch, video_break};
if (WaitForMultipleObjects(2, handles, FALSE, 0) == WAIT_TIMEOUT)
{
int decodeResult = video_decoder->DecodeChunk(frame_data->type, frame_data->data, frame_data->length);
if (decodeResult == ifc_avivideodecoder::AVI_SUCCESS)
{
void *data, *decoder_data;
while (video_decoder->GetPicture(&data, &decoder_data) == ifc_avivideodecoder::AVI_SUCCESS)
{
if (!video_opened)
{
int color_format;
double aspect_ratio=1.0;
int flip=0;
if (video_decoder->GetOutputProperties(&width, &height, &color_format, &aspect_ratio, &flip) == ifc_avivideodecoder::AVI_SUCCESS)
{
nsavi::VPRP *vprp = header_list.stream_list[video_stream_num].video_properties;
if (vprp)
{
uint32_t asp = vprp->aspect_ratio;
uint32_t aspect_x = HIWORD(asp);
uint32_t aspect_y = LOWORD(asp);
aspect_ratio = (double)vprp->frame_width / (double)vprp->frame_height / ((double)aspect_x / (double)aspect_y);
}
else
aspect_ratio = 1.0/aspect_ratio;
video_output->extended(VIDUSER_SET_THREAD_SAFE, 1, 0);
video_output->open(width, height, flip, aspect_ratio, color_format);
video_opened=true;
}
}
if (video_opened)
{
int timestamp=(int)(video_total_time*1000ULL/(uint64_t) header_list.stream_list[video_stream_num].stream_header->rate);
again:
int real_time =(int)GetOutputTime();
if (timestamp > (real_time+5))
{
HANDLE handles[] = {killswitch, video_break};
int ret=WaitForMultipleObjects(2, handles, FALSE, timestamp-real_time);
if (ret != WAIT_TIMEOUT)
{
video_decoder->FreePicture(data, decoder_data);
frame_data->Reset();
return ;
}
goto again; // TODO: handle paused state a little better than this
}
RGB32 *palette=0;
if (video_decoder->GetPalette(&palette) == ifc_avivideodecoder::AVI_SUCCESS)
{
video_output->extended(VIDUSER_SET_PALETTE, (INT_PTR)palette, 0);
}
video_output->draw(data);
}
video_total_time += header_list.stream_list[video_stream_num].stream_header->scale;
video_decoder->FreePicture(data, decoder_data);
}
}
}
// frame_data->Reset();
}
static DWORD CALLBACK VideoProcedure(LPVOID param)
{
SetThreadName(-1,"AVI_VideoProcedure");
HANDLE wait_handles[] = { killswitch, video_break, video_flush, video_resume, coded_frames_event };
while (1)
{
int ret = WaitForMultipleObjects(5, wait_handles, FALSE, INFINITE);
if (ret == WAIT_OBJECT_0)
{
break;
}
if (ret == WAIT_OBJECT_0 + 1) // video break
{
ResetEvent(coded_frames_event);
ResetEvent(video_break);
SetEvent(video_flush_done);
}
else if (ret == WAIT_OBJECT_0 + 2) // video flush
{
if (video_decoder)
video_decoder->Flush();
ResetEvent(video_flush);
coded_frames.Trim();
SetEvent(video_flush_done);
}
else if (ret == WAIT_OBJECT_0 + 3) // video resume
{
ResetEvent(video_resume);
SetEvent(coded_frames_event);
SetEvent(video_flush_done);
}
else if (ret == WAIT_OBJECT_0 + 4) // data from demuxer
{
FRAMEDATA *frame_data = 0;
while (frame_data = coded_frames.PopProcessed())
{
DecodeVideo(frame_data);
frame_data->Reset();
coded_frames.PushFree(frame_data);
}
}
};
if (video_opened && video_output)
video_output->close();
video_opened=false;
return 0;
}
static DWORD CALLBACK VideoReaderProcedure(LPVOID param)
{
VideoContext *ctx = (VideoContext *)param;
nsavi::avi_reader *reader = ctx->reader;
nsavi::Demuxer *demuxer = ctx->demuxer;
SetThreadName(-1,"AVI_VideoProcedure");
HANDLE wait_handles[] = { killswitch, video_break, video_flush, video_resume };
int waitTime = 0;
while (1)
{
int ret = WaitForMultipleObjects(4, wait_handles, FALSE, waitTime);
if (ret == WAIT_OBJECT_0)
{
break;
}
if (ret == WAIT_OBJECT_0 + 1) // video break
{
ResetEvent(coded_frames_event);
ResetEvent(video_break);
SetEvent(video_flush_done);
waitTime = INFINITE;
}
else if (ret == WAIT_OBJECT_0 + 2) // video flush
{
if (video_decoder)
video_decoder->Flush();
ResetEvent(video_flush);
coded_frames.Trim();
SetEvent(video_flush_done);
waitTime = 0;
}
else if (ret == WAIT_OBJECT_0 + 3) // video resume
{
ResetEvent(video_resume);
SetEvent(coded_frames_event);
SetEvent(video_flush_done);
waitTime = 0;
}
else if (ret == WAIT_TIMEOUT)
{
void *data=0;
uint32_t data_size = 0;
uint32_t data_type = 0;
int ret = demuxer->GetNextMovieChunk(reader, &data, &data_size, &data_type, video_stream_num);
if (ret != nsavi::READ_OK)
{
break;
}
int stream_number = GetStreamNumber(data_type);
uint16_t type = (data_type>>16);
if (stream_number == video_stream_num)
{
FRAMEDATA frame_data;
frame_data.data = data;
frame_data.length = data_size;
frame_data.type = type;
DecodeVideo(&frame_data);
frame_data.Reset();
}
else
free(data);
}
};
if (video_opened && video_output)
video_output->close();
video_opened=false;
free(ctx);
return 0;
}
bool CreateVideoReaderThread(nsavi::Demuxer *demuxer, nsavi::avi_reader *video_reader)
{
if (!video_decoder || video_only)
return false;
VideoContext *context = (VideoContext *)calloc(1, sizeof(VideoContext));
context->reader = video_reader;
context->demuxer = demuxer;
DWORD threadId = 0;
video_thread = CreateThread(0, 0, VideoReaderProcedure, context, 0, &threadId);
SetThreadPriority(video_thread, (INT)AGAVE_API_CONFIG->GetInt(playbackConfigGroupGUID, L"priority", THREAD_PRIORITY_HIGHEST));
return true;
}
bool OnVideo(uint16_t type, void *data, size_t length)
{
if (!video_decoder)
return false;
if (!video_only && !video_thread)
{
DWORD threadId;
video_thread = CreateThread(0, 0, VideoProcedure, 0, 0, &threadId);
SetThreadPriority(video_thread, (INT)AGAVE_API_CONFIG->GetInt(playbackConfigGroupGUID, L"priority", THREAD_PRIORITY_HIGHEST));
}
if (video_thread)
{
FRAMEDATA *new_frame = coded_frames.PopFree();
if (new_frame)
{
new_frame->Set(type, data, length);
coded_frames.PushProcessed(new_frame);
SetEvent(coded_frames_event);
}
return true;
}
else if (video_only)
{
FRAMEDATA *new_frame = coded_frames.PopFree();
if (new_frame)
{
new_frame->Set(type, data, length);
DecodeVideo(new_frame);
new_frame->Reset();
}
return true;
}
return false;
}
void Video_Stop()
{
SetEvent(killswitch);
if (video_only)
{
video_thread=0;
ResetEvent(coded_frames_event);
Nullsoft::Utility::AutoLock l(coded_frames_guard);
coded_frames.Trim();
if (video_opened && video_output)
video_output->close();
video_opened=false;
}
else
{
if (video_thread)
WaitForSingleObject(video_thread, INFINITE);
video_thread=0;
ResetEvent(coded_frames_event);
Nullsoft::Utility::AutoLock l(coded_frames_guard);
coded_frames.Trim();
}
}
void Video_Close()
{
video_opened=false;
if (video_decoder)
{
video_decoder->Close();
video_decoder=0;
}
}
void Video_Break()
{
if (!video_only && video_decoder)
{
SetEvent(video_break);
HANDLE events[2] = {video_flush_done, video_thread};
WaitForMultipleObjects(2, events, FALSE, INFINITE);
}
}
void Video_Flush()
{
if (video_decoder)
{
if (video_only)
{
video_decoder->Flush();
}
else
{
SetEvent(video_flush);
HANDLE events[2] = {video_flush_done, video_thread};
WaitForMultipleObjects(2, events, FALSE, INFINITE);
}
}
}
/*
bool Video_DecoderReady()
{
if (!video_decoder)
return true;
return !!video_decoder->Ready();
}
*/
Reference in New Issue View Git Blame Copy Permalink