bool CEncoderFFmpeg::Close()
{
if (m_Format) {
/* if there is anything still in the buffer */
if (m_BufferSize > 0) {
/* zero the unused space so we dont encode random junk */
memset(&m_Buffer[m_BufferSize], 0, m_NeededBytes - m_BufferSize);
/* write any remaining data */
WriteFrame();
}
/* write the eof flag */
delete[] m_Buffer;
m_Buffer = NULL;
WriteFrame();
/* write the trailer */
m_dllAvFormat.av_write_trailer(m_Format);
FlushStream();
FileClose();
/* cleanup */
m_dllAvCodec.avcodec_close(m_CodecCtx);
m_dllAvUtil.av_freep(&m_Stream );
m_dllAvUtil.av_freep(&m_Format->pb);
m_dllAvUtil.av_freep(&m_Format );
}
m_BufferSize = 0;
m_dllAvFormat.Unload();
m_dllAvUtil .Unload();
m_dllAvCodec .Unload();
return true;
}
void Animation::AppendFrame(Image *image) // writing only - NOTE: This method reserves the right to *modify* the image passed to it!!! [trf]
{
if(writeOptions.blurradius > 0.0f)
{
boost::scoped_ptr<Image> mask(Image::Create(image->GetWidth(), image->GetHeight(), Image::Bit_Map));
float r, g, b, f, t;
mask->FillBitValue(false);
if(writeOptions.bluredgethreshold < 1.0f)
ComputeBlurMask(*image, *mask.get());
for(int y = 0; y < image->GetHeight(); y++)
{
for(int x = 0; x < image->GetWidth(); x++)
{
if(mask->GetBitValue(x, y) == true)
{
image->GetRGBFTValue(x, y, r, g, b, f, t);
GetBlurredPixel(*image, x, y, r, g, b);
image->SetRGBFTValue(x, y, r, g, b, f, t);
}
}
}
}
WriteFrame(outFile, image);
totalFrames++;
}
TInt CCommFrameWriterAo::Write(CCsyMsgBufBpFrame* aBpFrame,
TBool aHighPriority)
/**
* This method is called to transmit a frame to the baseband.
*
* @param aBpFrame - Pointer to frame
* @param aHighPriority - Flag to indicate a high priority frame
*/
{
_LOG_L4C3(">>CCommFrameWriterAo::Write [aBpFrame=0x%x, aHighPriority=%d]",
aBpFrame,aHighPriority);
TInt ret = KErrNone;
// 1st check if we are already transmitting a frame
if (!IsActive())
{
_LOG_L4C1("Not currently writing a frame");
ret = WriteFrame(aBpFrame);
}
else
{
// add frame to the list of frames that need to be sent to the BP
_LOG_L2C1("Already writing a frame - add to queue");
AddToWaitingToSendList(aBpFrame, aHighPriority);
}
_LOG_L4C2("<<CCommFrameWriterAo::Write [ret=%d]",ret);
return ret;
}
CPU::State FifoPlayer::AdvanceFrame()
{
if (m_CurrentFrame >= m_FrameRangeEnd)
{
if (!m_Loop)
return CPU::State::PowerDown;
// If there are zero frames in the range then sleep instead of busy spinning
if (m_FrameRangeStart >= m_FrameRangeEnd)
return CPU::State::Stepping;
// When looping, reload the contents of all the BP/CP/CF registers.
// This ensures that each time the first frame is played back, the state of the
// GPU is the same for each playback loop.
m_CurrentFrame = m_FrameRangeStart;
LoadRegisters();
LoadTextureMemory();
FlushWGP();
}
if (m_FrameWrittenCb)
m_FrameWrittenCb();
if (m_EarlyMemoryUpdates && m_CurrentFrame == m_FrameRangeStart)
WriteAllMemoryUpdates();
WriteFrame(m_File->GetFrame(m_CurrentFrame), m_FrameInfo[m_CurrentFrame]);
++m_CurrentFrame;
return CPU::State::Running;
}
AVWRAP_DECL int AVWrapper_WriteFrame(uint8_t* pY, uint8_t* pCb, uint8_t* pCr)
{
g_pVFrame->data[0] = pY;
g_pVFrame->data[1] = pCb;
g_pVFrame->data[2] = pCr;
return WriteFrame(g_pVFrame);
}
void FStatsWriteFile::NewFrame( int64 TargetFrame )
{
SCOPE_CYCLE_COUNTER( STAT_StreamFile );
// Currently raw stat files are limited to 120 frames.
enum
{
MAX_NUM_RAWFRAMES = 120,
};
if( Header.bRawStatsFile )
{
if( FCommandStatsFile::FirstFrame == -1 )
{
FCommandStatsFile::FirstFrame = TargetFrame;
}
else if( TargetFrame > FCommandStatsFile::FirstFrame + MAX_NUM_RAWFRAMES )
{
FCommandStatsFile::Stop();
FCommandStatsFile::FirstFrame = -1;
return;
}
}
WriteFrame( TargetFrame );
SendTask();
}
static int WriteAudioFrame(AVFormatContext *oc, OutputStream *ost, AVI6 *avi)
{
AVCodecContext *c = NULL;
AVPacket pkt = { 0 };
AVFrame *frame = NULL;
int ret = 0;
int got_packet = 0;
int dst_nb_samples = 0;
av_init_packet(&pkt);
c = ost->st->codec;
frame = GetAudioFrame(ost, avi);
if (frame) {
// フォーマット変換後のサンプル数を決定
dst_nb_samples = av_rescale_rnd(swr_get_delay(ost->swr_ctx, frame->sample_rate) + frame->nb_samples,
c->sample_rate, c->sample_rate, AV_ROUND_UP);
//av_assert0(dst_nb_samples == frame->nb_samples);
// フレームを書き込み可能にする
ret = av_frame_make_writable(ost->frame);
if (ret < 0)
exit(1);
// 音声フォーマットを変換
ret = swr_convert(ost->swr_ctx,
ost->frame->data, dst_nb_samples,
(const uint8_t **)frame->data, frame->nb_samples);
if (ret < 0) {
fprintf(stderr, "Error while converting\n");
return 0;
}
frame = ost->frame;
frame->pts = av_rescale_q(ost->samples_count, (AVRational){1, c->sample_rate}, c->time_base);
ost->samples_count += dst_nb_samples;
ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
if (ret < 0) {
fprintf(stderr, "Error encoding audio frame: %s\n", MakeErrorString(ret));
return 0;
}
if (got_packet) {
ret = WriteFrame(oc, &c->time_base, ost->st, &pkt);
if (ret < 0) {
fprintf(stderr, "Error while writing audio frame: %s\n",
MakeErrorString(ret));
return 0;
}
}
}
return (frame || got_packet) ? 0 : 1;
}
static int WriteVideoFrame(AVFormatContext *oc, OutputStream *ost, BYTE* src_img)
{
int ret = 0;
AVCodecContext *c = NULL;
AVFrame *frame = NULL;
int got_packet = 0;
c = ost->st->codec;
frame = GetVideoFrame(ost, src_img);
if (oc->oformat->flags & AVFMT_RAWPICTURE) {
/* a hack to avoid data copy with some raw video muxers */
AVPacket pkt;
av_init_packet(&pkt);
if (!frame)
return 1;
pkt.flags |= AV_PKT_FLAG_KEY;
pkt.stream_index = ost->st->index;
pkt.data = (uint8_t *)frame;
pkt.size = sizeof(AVPicture);
pkt.pts = pkt.dts = frame->pts;
av_packet_rescale_ts(&pkt, c->time_base, ost->st->time_base);
ret = av_interleaved_write_frame(oc, &pkt);
} else {
AVPacket pkt = { 0 };
av_init_packet(&pkt);
// 映像をエンコード
ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
if (ret < 0) {
fprintf(stderr, "Error encoding video frame: %s\n", MakeErrorString(ret));
return 0;
}
if (got_packet) {
ret = WriteFrame(oc, &c->time_base, ost->st, &pkt);
} else {
ret = 0;
}
}
if (ret < 0) {
fprintf(stderr, "Error while writing video frame: %s\n", MakeErrorString(ret));
return 0;
}
return (frame || got_packet) ? 0 : 1;
}
bool FifoPlayer::Play()
{
if (!m_File)
return false;
if (m_File->GetFrameCount() == 0)
return false;
IsPlayingBackFifologWithBrokenEFBCopies = m_File->HasBrokenEFBCopies();
m_CurrentFrame = m_FrameRangeStart;
LoadMemory();
// This loop replaces the CPU loop that occurs when a game is run
while (PowerPC::GetState() != PowerPC::CPU_POWERDOWN)
{
if (PowerPC::GetState() == PowerPC::CPU_RUNNING)
{
if (m_CurrentFrame >= m_FrameRangeEnd)
{
if (m_Loop)
{
m_CurrentFrame = m_FrameRangeStart;
PowerPC::ppcState.downcount = 0;
CoreTiming::Advance();
}
else
{
PowerPC::Stop();
Host_Message(WM_USER_STOP);
}
}
else
{
if (m_FrameWrittenCb)
m_FrameWrittenCb();
if (m_EarlyMemoryUpdates && m_CurrentFrame == m_FrameRangeStart)
WriteAllMemoryUpdates();
WriteFrame(m_File->GetFrame(m_CurrentFrame), m_FrameInfo[m_CurrentFrame]);
++m_CurrentFrame;
}
}
}
IsPlayingBackFifologWithBrokenEFBCopies = false;
return true;
}
AVWRAP_DECL int AVWrapper_Close()
{
int ret;
// output buffered frames
if (g_pVCodec->capabilities & AV_CODEC_CAP_DELAY)
{
do
ret = WriteFrame(NULL);
while (ret > 0);
if (ret < 0)
return ret;
}
// output any remaining audio
do
{
ret = WriteAudioFrame();
}
while(ret > 0);
if (ret < 0)
return ret;
// write the trailer, if any.
av_write_trailer(g_pContainer);
// close the output file
if (!(g_pFormat->flags & AVFMT_NOFILE))
avio_close(g_pContainer->pb);
// free everything
if (g_pVStream)
{
avcodec_close(g_pVideo);
av_free(g_pVideo);
av_free(g_pVStream);
av_frame_free(&g_pVFrame);
}
if (g_pAStream)
{
avcodec_close(g_pAudio);
av_free(g_pAudio);
av_free(g_pAStream);
av_frame_free(&g_pAFrame);
av_free(g_pSamples);
fclose(g_pSoundFile);
}
av_free(g_pContainer);
return 0;
}
void FFMS_Track::Write(ZipFile &stream) const {
stream.Write<uint8_t>(TT);
stream.Write(TB.Num);
stream.Write(TB.Den);
stream.Write<int32_t>(MaxBFrames);
stream.Write<uint8_t>(UseDTS);
stream.Write<uint8_t>(HasTS);
stream.Write<uint64_t>(size());
if (empty()) return;
FrameInfo temp{};
for (size_t i = 0; i < size(); ++i)
WriteFrame(stream, Frames[i], i == 0 ? temp : Frames[i - 1], TT);
}
void ActionThread::processItem(int upperBound, MagickImage* const img, MagickImage* const imgNext, Action action)
{
/*
// need to reimplement using appsrc plugin of gstreamer
if(action == TYPE_IMAGE)
{
if(d->item->EffectName() == EFFECT_NONE)
upperBound = 1;
}
*/
for (int n = 0; n < upperBound && d->running; n++)
{
Frame* const frm = getFrame(d->item, img, imgNext, n, action);
ProcessFrame(frm);
WriteFrame(frm);
delete frm;
}
}
AVWRAP_DECL int AVWrapper_WriteFrame(uint8_t *buf)
{
int x, y, stride = g_Width * 4;
uint8_t *data[3];
// copy pointers, prepare source
memcpy(data, g_pVFrame->data, sizeof(data));
buf += (g_Height - 1) * stride;
// convert to YUV 4:2:0
for (y = 0; y < g_Height; y++) {
for (x = 0; x < g_Width; x++) {
int r = buf[x * 4 + 0];
int g = buf[x * 4 + 1];
int b = buf[x * 4 + 2];
int luma = (int)(0.299f * r + 0.587f * g + 0.114f * b);
data[0][x] = av_clip_uint8(luma);
if (!(x & 1) && !(y & 1)) {
int r = (buf[x * 4 + 0] + buf[(x + 1) * 4 + 0] +
buf[x * 4 + 0 + stride] + buf[(x + 1) * 4 + 0 + stride]) / 4;
int g = (buf[x * 4 + 1] + buf[(x + 1) * 4 + 1] +
buf[x * 4 + 1 + stride] + buf[(x + 1) * 4 + 1 + stride]) / 4;
int b = (buf[x * 4 + 2] + buf[(x + 1) * 4 + 2] +
buf[x * 4 + 2 + stride] + buf[(x + 1) * 4 + 2 + stride]) / 4;
int cr = (int)(-0.14713f * r - 0.28886f * g + 0.436f * b);
int cb = (int)( 0.615f * r - 0.51499f * g - 0.10001f * b);
data[1][x / 2] = av_clip_uint8(128 + cr);
data[2][x / 2] = av_clip_uint8(128 + cb);
}
}
buf += -stride;
data[0] += g_pVFrame->linesize[0];
if (y & 1) {
data[1] += g_pVFrame->linesize[1];
data[2] += g_pVFrame->linesize[2];
}
}
return WriteFrame(g_pVFrame);
}
int main(int argc, char** argv) {
if (argc < 2) {
printf("usage: deferred_shading <input_file (e.g. data/pp1280x720.bin)> [tasks iterations] [serial iterations]\n");
return 1;
}
static unsigned int test_iterations[] = {5, 3, 500}; //last value is for nframes, it is scale.
if (argc == 5) {
for (int i = 0; i < 3; i++) {
test_iterations[i] = atoi(argv[2 + i]);
}
}
InputData *input = CreateInputDataFromFile(argv[1]);
if (!input) {
printf("Failed to load input file \"%s\"!\n", argv[1]);
return 1;
}
Framebuffer framebuffer(input->header.framebufferWidth,
input->header.framebufferHeight);
int nframes = test_iterations[2];
double ispcCycles = 1e30;
for (int i = 0; i < test_iterations[0]; ++i) {
framebuffer.clear();
reset_and_start_timer();
for (int j = 0; j < nframes; ++j)
ispc::RenderStatic(&input->header, &input->arrays,
VISUALIZE_LIGHT_COUNT,
framebuffer.r, framebuffer.g, framebuffer.b);
double msec = get_elapsed_msec() / nframes;
printf("@time of ISPC + TASKS run:\t\t\t[%.3f] msec [%.3f fps]\n", msec, 1.0e3/msec);
ispcCycles = std::min(ispcCycles, msec);
}
printf("[ispc static + tasks]:\t\t[%.3f] msec to render "
"%d x %d image\n", ispcCycles,
input->header.framebufferWidth, input->header.framebufferHeight);
WriteFrame("deferred-ispc-static.ppm", input, framebuffer);
DeleteInputData(input);
return 0;
}
int CEncoderFFmpeg::Encode(int nNumBytesRead, BYTE* pbtStream)
{
while(nNumBytesRead > 0)
{
unsigned int space = m_NeededBytes - m_BufferSize;
unsigned int copy = (unsigned int)nNumBytesRead > space ? space : nNumBytesRead;
memcpy(&m_Buffer[m_BufferSize], pbtStream, space);
m_BufferSize += copy;
pbtStream += copy;
nNumBytesRead -= copy;
/* only write full packets */
if (m_BufferSize == m_NeededBytes)
if (!WriteFrame()) return 0;
}
return 1;
}
bool FifoPlayer::Play()
{
if (!m_File)
return false;
if (m_File->GetFrameCount() == 0)
return false;
m_CurrentFrame = m_FrameRangeStart;
LoadMemory();
// This loop replaces the CPU loop that occurs when a game is run
while (PowerPC::GetState() != PowerPC::CPU_POWERDOWN)
{
if (PowerPC::GetState() == PowerPC::CPU_RUNNING)
{
if (m_CurrentFrame >= m_FrameRangeEnd)
{
m_CurrentFrame = m_FrameRangeStart;
CoreTiming::downcount = 0;
CoreTiming::Advance();
}
else
{
if (m_FrameWrittenCb)
m_FrameWrittenCb();
if (m_EarlyMemoryUpdates && m_CurrentFrame == m_FrameRangeStart)
WriteAllMemoryUpdates();
WriteFrame(m_File->GetFrame(m_CurrentFrame), m_FrameInfo[m_CurrentFrame]);
++m_CurrentFrame;
}
}
}
return true;
}
int FifoPlayer::AdvanceFrame()
{
if (m_CurrentFrame >= m_FrameRangeEnd)
{
if (!m_Loop)
return CPU::CPU_POWERDOWN;
// If there are zero frames in the range then sleep instead of busy spinning
if (m_FrameRangeStart >= m_FrameRangeEnd)
return CPU::CPU_STEPPING;
m_CurrentFrame = m_FrameRangeStart;
}
if (m_FrameWrittenCb)
m_FrameWrittenCb();
if (m_EarlyMemoryUpdates && m_CurrentFrame == m_FrameRangeStart)
WriteAllMemoryUpdates();
WriteFrame(m_File->GetFrame(m_CurrentFrame), m_FrameInfo[m_CurrentFrame]);
++m_CurrentFrame;
return CPU::CPU_RUNNING;
}
void AVIWriter::writeFrame(unsigned char *framepre,long sizepre,unsigned char *frame,long size,bool bKeyframe)
{
WriteFrame(framepre, sizepre, frame, size, true, bKeyframe);
counter++;
}
int main(int argc, char** argv) {
if (argc != 2) {
printf("usage: deferred_shading <input_file (e.g. data/pp1280x720.bin)>\n");
return 1;
}
InputData *input = CreateInputDataFromFile(argv[1]);
if (!input) {
printf("Failed to load input file \"%s\"!\n", argv[1]);
return 1;
}
Framebuffer framebuffer(input->header.framebufferWidth,
input->header.framebufferHeight);
InitDynamicC(input);
#ifdef __cilk
InitDynamicCilk(input);
#endif // __cilk
int nframes = 5;
double ispcCycles = 1e30;
for (int i = 0; i < 5; ++i) {
framebuffer.clear();
reset_and_start_timer();
for (int j = 0; j < nframes; ++j)
ispc::RenderStatic(input->header, input->arrays,
VISUALIZE_LIGHT_COUNT,
framebuffer.r, framebuffer.g, framebuffer.b);
double mcycles = get_elapsed_mcycles() / nframes;
ispcCycles = std::min(ispcCycles, mcycles);
}
printf("[ispc static + tasks]:\t\t[%.3f] million cycles to render "
"%d x %d image\n", ispcCycles,
input->header.framebufferWidth, input->header.framebufferHeight);
WriteFrame("deferred-ispc-static.ppm", input, framebuffer);
#ifdef __cilk
double dynamicCilkCycles = 1e30;
for (int i = 0; i < 5; ++i) {
framebuffer.clear();
reset_and_start_timer();
for (int j = 0; j < nframes; ++j)
DispatchDynamicCilk(input, &framebuffer);
double mcycles = get_elapsed_mcycles() / nframes;
dynamicCilkCycles = std::min(dynamicCilkCycles, mcycles);
}
printf("[ispc + Cilk dynamic]:\t\t[%.3f] million cycles to render image\n",
dynamicCilkCycles);
WriteFrame("deferred-ispc-dynamic.ppm", input, framebuffer);
#endif // __cilk
double serialCycles = 1e30;
for (int i = 0; i < 5; ++i) {
framebuffer.clear();
reset_and_start_timer();
for (int j = 0; j < nframes; ++j)
DispatchDynamicC(input, &framebuffer);
double mcycles = get_elapsed_mcycles() / nframes;
serialCycles = std::min(serialCycles, mcycles);
}
printf("[C++ serial dynamic, 1 core]:\t[%.3f] million cycles to render image\n",
serialCycles);
WriteFrame("deferred-serial-dynamic.ppm", input, framebuffer);
#ifdef __cilk
printf("\t\t\t\t(%.2fx speedup from static ISPC, %.2fx from Cilk+ISPC)\n",
serialCycles/ispcCycles, serialCycles/dynamicCilkCycles);
#else
printf("\t\t\t\t(%.2fx speedup from ISPC + tasks)\n", serialCycles/ispcCycles);
#endif // __cilk
DeleteInputData(input);
return 0;
}
void GSDrawScanlineCodeGenerator::Generate()
{
// TODO: on linux/mac rsi, rdi, xmm6-xmm15 are all caller saved
push(rbx);
push(rsi);
push(rdi);
push(rbp);
push(r12);
push(r13);
sub(rsp, 8 + 10 * 16);
for(int i = 6; i < 16; i++)
{
vmovdqa(ptr[rsp + (i - 6) * 16], Xmm(i));
}
mov(r10, (size_t)&m_test[0]);
mov(r11, (size_t)&m_local);
mov(r12, (size_t)m_local.gd);
mov(r13, (size_t)m_local.gd->vm);
Init();
// rcx = steps
// rsi = fza_base
// rdi = fza_offset
// r10 = &m_test[0]
// r11 = &m_local
// r12 = m_local->gd
// r13 = m_local->gd.vm
// xmm7 = vf (sprite && ltf)
// xmm8 = z
// xmm9 = f
// xmm10 = s
// xmm11 = t
// xmm12 = q
// xmm13 = rb
// xmm14 = ga
// xmm15 = test
if(!m_sel.edge)
{
align(16);
}
L("loop");
TestZ(xmm5, xmm6);
// ebp = za
if(m_sel.mmin)
{
SampleTextureLOD();
}
else
{
SampleTexture();
}
// ebp = za
// xmm2 = rb
// xmm3 = ga
AlphaTFX();
// ebp = za
// xmm2 = rb
// xmm3 = ga
ReadMask();
// ebp = za
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm5 = zm
TestAlpha();
// ebp = za
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm5 = zm
ColorTFX();
// ebp = za
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm5 = zm
Fog();
// ebp = za
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm5 = zm
ReadFrame();
// ebx = fa
// ebp = za
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm5 = zm
// xmm6 = fd
TestDestAlpha();
// ebx = fa
// ebp = za
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm5 = zm
// xmm6 = fd
WriteMask();
// ebx = fa
// edx = fzm
// ebp = za
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm5 = zm
// xmm6 = fd
WriteZBuf();
// ebx = fa
// edx = fzm
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm6 = fd
AlphaBlend();
// ebx = fa
// edx = fzm
// xmm2 = rb
// xmm3 = ga
// xmm4 = fm
// xmm6 = fd
WriteFrame();
L("step");
// if(steps <= 0) break;
if(!m_sel.edge)
{
test(rcx, rcx);
jle("exit", T_NEAR);
Step();
jmp("loop", T_NEAR);
}
L("exit");
for(int i = 6; i < 16; i++)
{
vmovdqa(Xmm(i), ptr[rsp + (i - 6) * 16]);
}
add(rsp, 8 + 10 * 16);
pop(r13);
pop(r12);
pop(rbp);
pop(rdi);
pop(rsi);
pop(rbx);
ret();
}
void GSDrawScanlineCodeGenerator::Generate()
{
push(ebx);
push(esi);
push(edi);
push(ebp);
const int params = 16;
Init(params);
if(!m_sel.edge)
{
align(16);
}
L("loop");
// ecx = steps
// esi = fzbr
// edi = fzbc
// xmm0 = z/zi
// xmm2 = u (tme)
// xmm3 = v (tme)
// xmm5 = rb (!tme)
// xmm6 = ga (!tme)
// xmm7 = test
bool tme = m_sel.tfx != TFX_NONE;
TestZ(tme ? xmm5 : xmm2, tme ? xmm6 : xmm3);
// ecx = steps
// esi = fzbr
// edi = fzbc
// - xmm0
// xmm2 = u (tme)
// xmm3 = v (tme)
// xmm5 = rb (!tme)
// xmm6 = ga (!tme)
// xmm7 = test
SampleTexture();
// ecx = steps
// esi = fzbr
// edi = fzbc
// ebp = za
// - xmm2
// - xmm3
// - xmm4
// xmm5 = rb
// xmm6 = ga
// xmm7 = test
AlphaTFX();
// ecx = steps
// esi = fzbr
// edi = fzbc
// ebp = za
// xmm2 = gaf (TFX_HIGHLIGHT || TFX_HIGHLIGHT2 && !tcc)
// xmm5 = rb
// xmm6 = ga
// xmm7 = test
if(m_sel.fwrite)
{
movdqa(xmm3, xmmword[&m_env.fm]);
}
if(m_sel.zwrite)
{
movdqa(xmm4, xmmword[&m_env.zm]);
}
// ecx = steps
// esi = fzbr
// edi = fzbc
// ebp = za
// xmm2 = gaf (TFX_HIGHLIGHT || TFX_HIGHLIGHT2 && !tcc)
// xmm3 = fm
// xmm4 = zm
// xmm5 = rb
// xmm6 = ga
// xmm7 = test
TestAlpha();
// ecx = steps
// esi = fzbr
// edi = fzbc
// ebp = za
// xmm2 = gaf (TFX_HIGHLIGHT || TFX_HIGHLIGHT2 && !tcc)
// xmm3 = fm
// xmm4 = zm
// xmm5 = rb
// xmm6 = ga
// xmm7 = test
ColorTFX();
// ecx = steps
// esi = fzbr
// edi = fzbc
// ebp = za
// xmm3 = fm
// xmm4 = zm
// xmm5 = rb
// xmm6 = ga
// xmm7 = test
Fog();
// ecx = steps
// esi = fzbr
// edi = fzbc
// ebp = za
// xmm3 = fm
// xmm4 = zm
// xmm5 = rb
// xmm6 = ga
// xmm7 = test
ReadFrame();
// ecx = steps
// esi = fzbr
// edi = fzbc
// ebp = za
// xmm2 = fd
// xmm3 = fm
// xmm4 = zm
// xmm5 = rb
// xmm6 = ga
// xmm7 = test
TestDestAlpha();
// fm |= test;
// zm |= test;
if(m_sel.fwrite)
{
por(xmm3, xmm7);
}
if(m_sel.zwrite)
{
por(xmm4, xmm7);
}
// int fzm = ~(fm == GSVector4i::xffffffff()).ps32(zm == GSVector4i::xffffffff()).mask();
pcmpeqd(xmm1, xmm1);
if(m_sel.fwrite && m_sel.zwrite)
{
movdqa(xmm0, xmm1);
pcmpeqd(xmm1, xmm3);
pcmpeqd(xmm0, xmm4);
packssdw(xmm1, xmm0);
}
else if(m_sel.fwrite)
{
pcmpeqd(xmm1, xmm3);
packssdw(xmm1, xmm1);
}
else if(m_sel.zwrite)
{
pcmpeqd(xmm1, xmm4);
packssdw(xmm1, xmm1);
}
pmovmskb(edx, xmm1);
not(edx);
// ebx = fa
// ecx = steps
// edx = fzm
// esi = fzbr
// edi = fzbc
// ebp = za
// xmm2 = fd
// xmm3 = fm
// xmm4 = zm
// xmm5 = rb
// xmm6 = ga
WriteZBuf();
// ebx = fa
// ecx = steps
// edx = fzm
// esi = fzbr
// edi = fzbc
// - ebp
// xmm2 = fd
// xmm3 = fm
// - xmm4
// xmm5 = rb
// xmm6 = ga
AlphaBlend();
// ebx = fa
// ecx = steps
// edx = fzm
// esi = fzbr
// edi = fzbc
// xmm2 = fd
// xmm3 = fm
// xmm5 = rb
// xmm6 = ga
WriteFrame(params);
L("step");
// if(steps <= 0) break;
if(!m_sel.edge)
{
test(ecx, ecx);
jle("exit", T_NEAR);
Step();
jmp("loop", T_NEAR);
}
L("exit");
pop(ebp);
pop(edi);
pop(esi);
pop(ebx);
ret(8);
}
void CCommFrameWriterAo::RunL()
/**
* This method is called when a write to the LDD completes.
*/
{
_LOG_L4C1(" ");
_LOG_L4C2(">>CCommFrameWriterAo::RunL [iStatus=%d] - written to LDD",
iStatus.Int());
if (iStatus.Int())
{
_LOG_L1C2("** Error writing to LDD ** [iStatus=%d]",iStatus.Int());
if (!iCompleteWhenSent)
{
// The frame being sent was not the last or only one for this dlc, other
// frames exist
// go through list and remove other frames to send for this dlc
RemoveAnyDlcFramesOnWriteList(iDlcNum, EFalse);
iCompleteWhenSent = ETrue;
}
}
if (iCompleteWhenSent)
{
iCompleteWhenSent = EFalse;
_LOG_L3C2("Complete write [iDlcNum=%d]",iDlcNum);
CompleteWrite(iDlcNum,iStatus.Int());
}
// check for another message that needs to be sent to the baseband
CCsyMsgBufBpFrame* bpFrame = GetFrameToWrite();
if (bpFrame)
{
TInt ret = KErrNone;
do
{
ret = WriteFrame(bpFrame);
if (ret)
{
_LOG_L1C2("** Write frame failed [ret=%d] **",ret);
if (!iCompleteWhenSent)
{
// go through list and remove other frames to send for this dlc
RemoveAnyDlcFramesOnWriteList(iDlcNum, EFalse);
}
}
// Loop around if there is an error and try and send the next frame
}
while (ret);
}
else
{
_LOG_L3C1("Finished all writes - nothing more to send to LDD");
}
_LOG_L4C1("<<CCommFrameWriterAo::RunL");
_LOG_L3C1(" "); // please leave this separator in
}
void XYUVHeader::Run(const ::options & options) {
// If help has been requested, print it and quit.
if (options.print_help) {
PrintHelp();
return;
}
// Otherwise do something useful.
#ifdef INSTALL_FORMATS_PATH
// Load base formats from installation path
config_manager_.load_configurations(INSTALL_FORMATS_PATH);
#endif
// Load all additional formats supplied on the command line.
for (const auto & path : options.additional_config_directories) {
config_manager_.load_configurations(path);
}
// If a list of all formats has been requested, print it and quit.
if (options.list_all_formats) {
PrintAllFormats();
return;
}
// Try to aquire each output stream.
bool detect_concatinate = options.concatinate;
std::vector<std::string> output_names;
if (options.writeout) {
// Make a set of output names to do argument validation.
std::unordered_set<std::string> out_name_set;
if ( options.output_name.size() == 0 ) {
// If concatinating, use first file name as output.
if (detect_concatinate) {
std::string out_path = strip_suffix(options.input_files[0]) + ".xyuv";
out_name_set.emplace(out_path);
output_names.emplace_back(out_path);
}
else {
for (const auto & in_file : options.input_files ) {
std::string out_path = strip_suffix(in_file) + ".xyuv";
out_name_set.insert(out_path);
output_names.emplace_back(out_path);
}
}
}
else {
for (const auto & out_path : options.output_name ) {
out_name_set.insert(out_path);
output_names.emplace_back(out_path);
}
}
// Check that no two output files overwrite one another.
if (out_name_set.size() != output_names.size()) {
throw std::invalid_argument("The same output name is given more than once. This is illegal for one invocation of the program.");
}
// Check that no input file is the same as an output file.
// We don't account for relative paths etc here, but we won't care for now.
for (const auto & in_path : options.input_files) {
if (out_name_set.find(in_path) != out_name_set.end()) {
throw std::invalid_argument("File '" + in_path + "' given as both an input and an output file, this is illegal.");
}
}
// Check that the number of output files matches the number of input files
// or one.
if (output_names.size() != 1 && output_names.size() != options.input_files.size() ) {
throw std::invalid_argument("If supplied, the number of output files must exactly match the number of input files or one.");
}
if (output_names.size() == 1 && options.input_files.size() > 1) {
detect_concatinate = true;
}
}
// Check validity of formats:
std::vector<xyuv::format_template> format_templates;
std::vector<xyuv::chroma_siting> sitings;
std::vector<xyuv::conversion_matrix> matrices;
for (const auto & format_template : options.output_formats ) {
try {
// Try to load the format-template from file.
format_templates.push_back(xyuv::config_manager::load_format_template(format_template));
} catch (std::runtime_error & e) {
try {
// If that failed look it up in the config manager.
format_templates.push_back(config_manager_.get_format_template(format_template));
} catch (std::exception e2) {
std::string err_msg = std::string("Could not load format template ") + format_template +
": " + e.what() + " and " + e2.what() + ". Please check the spelling of the argument.";
throw std::invalid_argument(std::string(err_msg));
}
}
}
if (format_templates.size() != 1 && format_templates.size() != options.input_files.size()) {
throw std::invalid_argument("The number of format templates must exactly match the number of input files or one (which implies all input files have the same format).");
}
for (const auto & siting : options.output_siting ) {
try {
// Try to load the siting from file.
sitings.push_back(xyuv::config_manager::load_chroma_siting(siting));
} catch (std::runtime_error & e) {
try {
// If that failed look it up in the config manager.
sitings.push_back(config_manager_.get_chroma_siting(siting));
} catch (std::exception e2) {
std::string err_msg = std::string("Could not load chroma siting ") + siting +
": " + e.what() + " and " + e2.what() + ". Please check the spelling of the argument.";
throw std::invalid_argument(std::string(err_msg));
}
}
}
if (sitings.size() != 1 && sitings.size() != options.input_files.size()) {
throw std::invalid_argument("The number of chroma sitings must exactly match the number of input files or one (which implies all input files have the same chroma siting).");
}
for (const auto & matrix : options.output_matrix ) {
try {
// Try to load the matrix from file.
matrices.push_back(xyuv::config_manager::load_conversion_matrix(matrix));
} catch (std::runtime_error & e) {
try {
// If that failed look it up in the config manager.
matrices.push_back(config_manager_.get_conversion_matrix(matrix));
} catch (std::exception e2) {
std::string err_msg = std::string("Could not load conversion matrix ") + matrix +
": " + e.what() + " and " + e2.what() + ". Please check the spelling of the argument.";
throw std::invalid_argument(std::string(err_msg));
}
}
}
if (matrices.size() != 1 && matrices.size() != options.input_files.size()) {
throw std::invalid_argument("The number of conversion matrices must exactly match the number of input files or one (which implies all input files have the same conversion matrix).");
}
// Do some extra checking for the chroma siting, which must match the subsampling mode of the format.
if (sitings.size() == 1 && format_templates.size() > 1) {
for (std::size_t i = 0; i < format_templates.size(); i++) {
if (!(sitings[0].subsampling == format_templates[i].subsampling)) {
throw std::invalid_argument("Sub-sampling mismatch, for format template #"
+ std::to_string(i) + "'" + options.output_formats[i] + "'"
+ " corresponding chroma siting expects subsampling mode: "
+ std::to_string(sitings[0].subsampling.macro_px_w) + "x" + std::to_string(sitings[0].subsampling.macro_px_h)
+ " got: "
+ std::to_string(format_templates[i].subsampling.macro_px_w) + "x" + std::to_string(format_templates[i].subsampling.macro_px_h)
);
}
}
}
if (options.display && options.input_files.size() != 1 ) {
throw std::invalid_argument("--display only supported for a single input.");
}
if (options.input_files.size() == 0) {
throw std::logic_error("Missing input files.");
}
if (options.input_files.size() > 0 && options.image_w * options.image_h == 0) {
throw std::logic_error("Image size must be non-zero.");
}
std::unique_ptr<std::ofstream> fout;
if (detect_concatinate) {
fout.reset(new std::ofstream(output_names[0], std::ios::binary | std::ios::app ));
if (!(*fout)) {
throw std::runtime_error("Could not open output file: '" + output_names[0] + "' for writing");
}
}
// At this point everything looks good :) Lets load some formats.
for ( std::size_t i = 0; i < options.input_files.size(); i++) {
xyuv::format target_format = xyuv::create_format(
options.image_w,
options.image_h,
format_templates.size() == 1 ? format_templates[0] : format_templates[i],
matrices.size() == 1 ? matrices[0] : matrices[i],
sitings.size() == 1 ? sitings[0] : sitings[i]
);
xyuv::frame frame = LoadConvertFrame(target_format, options.input_files[i]);
// If --flip-y is set then change the image origin to the inverse.
if (options.flip_y) {
switch (frame.format.origin) {
case xyuv::image_origin::UPPER_LEFT:
frame.format.origin = xyuv::image_origin::LOWER_LEFT;
break;
case xyuv::image_origin::LOWER_LEFT:
frame.format.origin = xyuv::image_origin::UPPER_LEFT;
break;
default:
break;
}
}
if (options.writeout) {
if (options.concatinate) {
// Append file at end of concatinated string.
xyuv::write_frame(*fout, frame);
}
else {
try {
WriteFrame(frame, output_names[i]);
} catch (std::exception & e) {
std::cout << "[Warning] Error occured while writing file '" <<
output_names[i] << "'\n " <<
e.what() << "\n Skipping file." << std::endl;
}
}
}
if (options.display) {
Display(frame);
}
}
}
void newVideoRenderTarget::slotConsumeFrame(const QImage &image, const int frameNumber)
{
WriteFrame(writer, image);
}
void GPUDrawScanlineCodeGenerator::Generate()
{
push(esi);
push(edi);
Init();
align(16);
L("loop");
// GSVector4i test = m_test[7 + (steps & (steps >> 31))];
mov(edx, ecx);
sar(edx, 31);
and(edx, ecx);
shl(edx, 4);
movdqa(xmm7, ptr[edx + (size_t)&m_test[7]]);
// movdqu(xmm1, ptr[edi]);
movq(xmm1, qword[edi]);
movhps(xmm1, qword[edi + 8]);
// ecx = steps
// esi = tex (tme)
// edi = fb
// xmm1 = fd
// xmm2 = s
// xmm3 = t
// xmm4 = r
// xmm5 = g
// xmm6 = b
// xmm7 = test
TestMask();
SampleTexture();
// xmm1 = fd
// xmm3 = a
// xmm4 = r
// xmm5 = g
// xmm6 = b
// xmm7 = test
// xmm0, xmm2 = free
ColorTFX();
AlphaBlend();
Dither();
WriteFrame();
L("step");
// if(steps <= 0) break;
test(ecx, ecx);
jle("exit", T_NEAR);
Step();
jmp("loop", T_NEAR);
L("exit");
pop(edi);
pop(esi);
ret(8);
}
void AVIWriter::writeAudio(unsigned char *frame,long size)
{
WriteFrame(0, 0, frame, size, false, true);
audio_counter++;
}
