cm-avisynth.cpp

avisynth-source-0.3.zip,avi edit src

#include "prTypes.h"
#include "prCompile.h"
#include "prWinEnv.h"
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "resource.h"

#include "../avisynth.h"

HMODULE g_hmodule;

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD, LPVOID) {
  g_hmodule = (HMODULE) hinstDLL;
  return TRUE;
}

const char* Sprintf(const char* fmt, ...) {
  va_list val;
  va_start(val, fmt);
  static char buf[1024];
  wvsprintf(buf, fmt, val);
  va_end(val);
  return buf;
}


int CompStartup(compStdParms* stdParms, compInfoRec* infoRec) {
  infoRec->fileType = 'LSVA';
  infoRec->classID = 'LSVA';
  infoRec->hasSetup = false;
  infoRec->compilesVideo = true;
  infoRec->compilesAudio = true;
  infoRec->hasAllocator = true;
  infoRec->canCopyFrames = false;
  infoRec->canOpen = true;
  infoRec->singleFrame = false;
  lstrcpy(infoRec->compilerName, "Link to Avisynth");
  infoRec->version = 1;
  return comp_ErrNone;
}


int CompGetIndFormat(compStdParms* stdParms, compFileInfoRec* fileInfoRec, int idx) {
  if (idx != 0)
    return comp_BadFormatIndex;

  fileInfoRec->subtype = compUncompressed;
  lstrcpy(fileInfoRec->name, "(uncompressed)");
  fileInfoRec->canForceKeyframes = true;
  fileInfoRec->depthsSupported = compDepth24;
  fileInfoRec->paletteAtDepth = 0;
  fileInfoRec->frameMultiple = 1;
  fileInfoRec->minWidth = 4;
  fileInfoRec->minHeight = 4;
  fileInfoRec->maxWidth = 16384;
  fileInfoRec->maxHeight = 16384;
  fileInfoRec->canDoFields = true;
  fileInfoRec->canDoQuality = false;
  fileInfoRec->canSetDataRate = false;
  fileInfoRec->hasSetup = false;
  fileInfoRec->canDelta = false;
  fileInfoRec->fixedTimebase = false;
  fileInfoRec->defaultQuality = -1;
  fileInfoRec->defaultKeyFrameRate = -1;
  return comp_ErrNone;
}


int CompGetAudioIndFormat(compStdParms* stdParms, compAudioInfoRec* audioInfoRec, int idx) {
  if (idx != 0)
    return comp_BadFormatIndex;

  audioInfoRec->subtype = compUncompressed;
  audioInfoRec->hasSetup = false;
  lstrcpy(audioInfoRec->name, "(uncompressed)");
  audioInfoRec->audioFormats = 0;
  return comp_ErrNone;
}


bool done;
static INT_PTR CALLBACK MainDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  if (uMsg == WM_CLOSE || (uMsg == WM_COMMAND && LOWORD(wParam) == IDOK))
    done = true;
  return FALSE;
}


#include "../ipc.h"

int CompDoCompile (compStdParms* stdParms, compDoCompileInfo* doCompileRec)
{
  const char* name = strrchr(doCompileRec->outputFile.name, '\\');
  if (name)
    ++name;
  else
    name = doCompileRec->outputFile.name;

  int video_size = doCompileRec->outputRec.width * doCompileRec->outputRec.height * 4;
  int audio_size = stdParms->funcs->audioFuncs->getBlipMax(doCompileRec->compileSeqID);
  int sizeof_ipc_data = sizeof(AvisynthIPCData) + max(video_size, audio_size);

  HANDLE mutex = CreateMutex(NULL, FALSE, Sprintf("Avisynth__semaphore__%s", name));
  HANDLE request = CreateEvent(NULL, FALSE, FALSE, Sprintf("Avisynth__request__%s", name));
  HANDLE reply = CreateEvent(NULL, FALSE, FALSE, Sprintf("Avisynth__reply__%s", name));
  HANDLE filemap = CreateFileMapping(HANDLE(-1), NULL, PAGE_READWRITE, 0, sizeof_ipc_data, Sprintf("Avisynth__data__%s", name));
  if (!mutex || !request || !reply || !filemap) {
    MessageBox(NULL, "Unable to create IPC objects.  Try using a different file name.", "Avisynth Premiere plugin", MB_OK);
    return comp_ErrInUse;
  }

  AvisynthIPCData* ipc_data = (AvisynthIPCData*) MapViewOfFile(filemap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);

  memset(ipc_data, 0, sizeof_ipc_data);
  ipc_data->magic = 'LSVA';
  ipc_data->ver = 1;
  ipc_data->vi.num_frames = doCompileRec->endFrame - doCompileRec->startFrame + 1;
  // what is doCompileRec->outputRec.timebase.value???
  ipc_data->vi.fps_numerator = doCompileRec->outputRec.timebase.scale;
  ipc_data->vi.fps_denominator = doCompileRec->outputRec.timebase.sampleSize;
  if (doCompileRec->outputRec.doVideo) {
    ipc_data->vi.width = doCompileRec->outputRec.width;
    ipc_data->vi.height = doCompileRec->outputRec.height;
    ipc_data->vi.pixel_type = VideoInfo::BGR24;
  }
  if (doCompileRec->outputRec.doAudio) {
    ipc_data->vi.audio_samples_per_second = doCompileRec->outputRec.audrate;
    ipc_data->vi.stereo = !!doCompileRec->outputRec.stereo;
    ipc_data->vi.sixteen_bit = (doCompileRec->outputRec.audsamplesize==16);
    ipc_data->vi.num_audio_samples = ipc_data->vi.AudioSamplesFromFrames(ipc_data->vi.num_frames);
  }

  {
    void* buf = ipc_data->data;
    compGetFrameReturnRec gfrr;
    stdParms->funcs->videoFuncs->getFrame(doCompileRec->startFrame, &buf, &ipc_data->size, &gfrr, false, doCompileRec->compileSeqID);
  }

  done = false;
  HWND hwnd = CreateDialog(g_hmodule, MAKEINTRESOURCE(IDD_MAIN), NULL, MainDialogProc);
  SetWindowText(GetDlgItem(hwnd, IDC_COMMAND), Sprintf("IPCSource(\"%s\")", name));
  ShowWindow(hwnd, SW_SHOW);

//    int foo = int(44100*100*__int64(i+1)/2997 - 44100*100*__int64(i)/2997) * 4;

  for (;;) {
    DWORD result = MsgWaitForMultipleObjects(1, &request, FALSE, INFINITE, QS_ALLINPUT);
    if (result == WAIT_OBJECT_0) {
      unsigned char* buf = ipc_data->data;
      if (ipc_data->audio) {
        unsigned char** bbuf = &buf;
        long framecount = 1;
        stdParms->funcs->audioFuncs->getAudio(ipc_data->requested_frame + doCompileRec->startFrame, &framecount, &ipc_data->size, 0, (char***)&bbuf, doCompileRec->compileSeqID);
        if (*bbuf != ipc_data->data)
          memcpy(ipc_data->data, *bbuf, ipc_data->size);
      } else {
        compGetFrameReturnRec gfrr;
        ipc_data->error_return = stdParms->funcs->videoFuncs->getFrame(ipc_data->requested_frame + doCompileRec->startFrame, (void**)&buf, &ipc_data->size, &gfrr, false, doCompileRec->compileSeqID);
        if (buf != ipc_data->data)
          memcpy(ipc_data->data, buf, ipc_data->size * ipc_data->vi.height);
      }
      SetEvent(reply);
    } else {
      MSG msg;
      while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
        if (!IsDialogMessage(hwnd, &msg)) {
          TranslateMessage(&msg);
          DispatchMessage(&msg);
        }
      }
      if (done)
        break;
    }
  }
  ipc_data->magic = 'ENOG';
  DestroyWindow(hwnd);
  CloseHandle(mutex);
  CloseHandle(request);
  CloseHandle(reply);
  UnmapViewOfFile(ipc_data);
  CloseHandle(filemap);
  return comp_ErrNone;
}

/*
	char					*buffer;
	long					rowbytes;
	compGetFrameReturnRec	getFrameRet;
	int						ret;

	// Call the getFrame callback to get the pixels
	ret = stdParms->funcs->videoFuncs->getFrame(doCompileRec->startFrame, (void**)&buffer, &rowbytes, &getFrameRet, 0, doCompileRec->compileSeqID);

	// ...and write the frame
	if (ret == comp_ErrNone)
		ret = SaveVxxFrame(stdParms, buffer, rowbytes, &doCompileRec->outputRec, doCompileRec->outputFileRef);

	return ret;
*/


int CompQueryOutputFormat (compStdParms *stdParms, compOutputRec *outputRec) {
  if (!outputRec->doVideo)
    return comp_OutputFormatDecline;
  return comp_OutputFormatAccept;
}


PREMPLUGENTRY xCompileEntry(int selector, compStdParms* stdParms, long param1, long param2) {
  switch (selector) {
	case compStartup:
      return CompStartup(stdParms, (compInfoRec *)param1);
	case compGetIndFormat:
      return CompGetIndFormat(stdParms, (compFileInfoRec *)param1, param2);
	case compGetAudioIndFormat:
      return CompGetAudioIndFormat(stdParms, (compAudioInfoRec *)param1, param2);
	case compQueryOutputFormat:
      return CompQueryOutputFormat(stdParms, (compOutputRec *)param1);
	case compDoCompile:
      return CompDoCompile(stdParms, (compDoCompileInfo *)param1);
    default:
      return comp_ErrNone;
  }
}