main.cpp

avisynth-source-0.3.zip,avi edit src

}

////////////////////////////////////////////////////////////////////////
//
//		CAVIFileSynth
//
////////////////////////////////////////////////////////////////////////

STDMETHODIMP CAVIFileSynth::CreateStream(PAVISTREAM *ppStream, AVISTREAMINFOW *psi) {
	_RPT1(0,"%p->CAVIFileSynth::CreateStream()\n", this);
	return S_OK;//AVIERR_READONLY;
}

STDMETHODIMP CAVIFileSynth::EndRecord() {
	_RPT1(0,"%p->CAVIFileSynth::EndRecord()\n", this);
	return AVIERR_READONLY;
}

STDMETHODIMP CAVIFileSynth::Save(LPCSTR szFile, AVICOMPRESSOPTIONS FAR *lpOptions,
				AVISAVECALLBACK lpfnCallback) {
	_RPT1(0,"%p->CAVIFileSynth::Save()\n", this);
	return AVIERR_READONLY;
}

STDMETHODIMP CAVIFileSynth::ReadData(DWORD fcc, LPVOID lp, LONG *lpcb) {
	_RPT1(0,"%p->CAVIFileSynth::ReadData()\n", this);
	return AVIERR_NODATA;
}

STDMETHODIMP CAVIFileSynth::WriteData(DWORD fcc, LPVOID lpBuffer, LONG cbBuffer) {
	_RPT1(0,"%p->CAVIFileSynth::WriteData()\n", this);
	return AVIERR_READONLY;
}

STDMETHODIMP CAVIFileSynth::DeleteStream(DWORD fccType, LONG lParam) {
	_RPT1(0,"%p->CAVIFileSynth::DeleteStream()\n", this);
	return AVIERR_READONLY;
}


CAVIFileSynth::CAVIFileSynth(const CLSID& rclsid) {
	_RPT0(0,"CAVIFileSynth::CAVIFileSynth()\n");

	m_refs = 0; AddRef();

    memset(&vi, 0, sizeof(VideoInfo));
}

CAVIFileSynth::~CAVIFileSynth() {
	_RPT0(0,"CAVIFileSynth::~CAVIFileSynth()\n");
}


STDMETHODIMP CAVIFileSynth::Open(LPCSTR szFile, UINT mode, LPCOLESTR lpszFileName) {

	_RPT2(0,"CAVIFileSynth::Open(\"%s\", %08lx)\n", szFile, mode);

	if (mode & (OF_CREATE|OF_WRITE))
      return E_FAIL;

//	if (!(hmmio = mmioOpen((char *)szFile, NULL, MMIO_READ)))
//		return E_FAIL;

    filter_chain = CreateFilterChain(szFile);

    if (filter_chain) {
      filter_chain->GetVideoInfo(&vi);
      return S_OK;
    } else {
      return E_FAIL;
    }
}

STDMETHODIMP CAVIFileSynth::Info(AVIFILEINFOW *pfi, LONG lSize) {

	_RPT0(0,"CAVIFileSynth::Info()\n");

	if (!pfi || !filter_chain) return E_FAIL;

	pfi->dwMaxBytesPerSec		= 0;
	pfi->dwFlags				= AVIFILEINFO_HASINDEX | AVIFILEINFO_ISINTERLEAVED;
	pfi->dwCaps					= AVIFILECAPS_CANREAD | AVIFILECAPS_ALLKEYFRAMES | AVIFILECAPS_NOCOMPRESSION;
	pfi->dwStreams				= vi.audio_samples_per_second ? 2 : 1;
	pfi->dwSuggestedBufferSize	= 0;
	pfi->dwWidth				= vi.width;
	pfi->dwHeight				= vi.height;
	pfi->dwEditCount			= 0;

    pfi->dwRate					= vi.fps_numerator;
	pfi->dwScale				= vi.fps_denominator;
	pfi->dwLength				= vi.num_frames;

    wcscpy(pfi->szFileType, L"Avisynth");

	return S_OK;
}

STDMETHODIMP CAVIFileSynth::GetStream(PAVISTREAM *ppStream, DWORD fccType, LONG lParam) {
	CAVIStreamSynth *casr;

	_RPT4(0,"%p->CAVIFileSynth::GetStream(%p, %08lx, %ld)\n", this, ppStream, fccType, lParam);

	*ppStream = NULL;

	if (!fccType) {
		if (lParam==0) fccType = streamtypeVIDEO;
		else if (lParam==1) {
			lParam = 0;
			fccType = streamtypeAUDIO;
		}
	}

	if (lParam > 0) return AVIERR_NODATA;

	if (fccType == streamtypeVIDEO) {
		if (!vi.HasVideo()) return AVIERR_NODATA;

        if (!(casr = new CAVIStreamSynth(this, false)))
			return AVIERR_MEMORY;

		*ppStream = (IAVIStream *)casr;

	} else if (fccType == streamtypeAUDIO) {
		if (!vi.HasAudio()) return AVIERR_NODATA;

		if (!(casr = new CAVIStreamSynth(this, true)))
			return AVIERR_MEMORY;

		*ppStream = (IAVIStream *)casr;
	} else
		return AVIERR_NODATA;

	return 0;
}


////////////////////////////////////////////////////////////////////////
//
//		CAVIStreamSynth
//
////////////////////////////////////////////////////////////////////////

STDMETHODIMP CAVIStreamSynth::Create(LONG lParam1, LONG lParam2) {
	_RPT1(0,"%p->CAVIStreamSynth::Create()\n", this);
	return AVIERR_READONLY;
}

STDMETHODIMP CAVIStreamSynth::Delete(LONG lStart, LONG lSamples) {
	_RPT1(0,"%p->CAVIStreamSynth::Delete()\n", this);
	return AVIERR_READONLY;
}

STDMETHODIMP CAVIStreamSynth::ReadData(DWORD fcc, LPVOID lp, LONG *lpcb) {
	_RPT1(0,"%p->CAVIStreamSynth::ReadData()\n", this);
	return AVIERR_NODATA;
}

STDMETHODIMP CAVIStreamSynth::SetFormat(LONG lPos, LPVOID lpFormat, LONG cbFormat) {
	_RPT1(0,"%p->CAVIStreamSynth::SetFormat()\n", this);
	return AVIERR_READONLY;
}

STDMETHODIMP CAVIStreamSynth::WriteData(DWORD fcc, LPVOID lpBuffer, LONG cbBuffer) {
	_RPT1(0,"%p->CAVIStreamSynth::WriteData()\n", this);
	return AVIERR_READONLY;
}

STDMETHODIMP CAVIStreamSynth::SetInfo(AVISTREAMINFOW *psi, LONG lSize) {
	return AVIERR_READONLY;
}

CAVIStreamSynth::CAVIStreamSynth(CAVIFileSynth *parentPtr, bool isAudio) {
  _RPT2(0,"%p->CAVIStreamSynth(%s)\n", this, isAudio ? "audio" : "video");
  m_refs = 0; AddRef();

  parent			= parentPtr;
  fAudio			= isAudio;
  myvideobuf = NULL;

  parent->AddRef();
}

CAVIStreamSynth::~CAVIStreamSynth() {
  _RPT1(0,"%p->~CAVIStreamSynth()\n", this);

  if (parent)
    parent->Release();

  if (myvideobuf)
    delete[] myvideobuf;
}

STDMETHODIMP_(LONG) CAVIStreamSynth::Info(AVISTREAMINFOW *psi, LONG lSize) {
	_RPT3(0,"%p->CAVIStreamSynth::Info(%p, %ld)\n", this, psi, lSize);

	AVISTREAMINFOW asi;

//    VideoInfo vi;
//    parent->filter_chain->GetVideoInfo(&vi);
    const VideoInfo& vi = parent->vi;

    memset(&asi, 0, sizeof(asi));
    asi.fccType = fAudio ? streamtypeAUDIO : streamtypeVIDEO;
    asi.fccHandler = 0;
    asi.dwQuality = DWORD(-1);
    if (fAudio) {
      int bytes_per_sample = vi.BytesPerAudioSample();
      asi.dwScale = bytes_per_sample;
      asi.dwRate = vi.audio_samples_per_second * bytes_per_sample;
      asi.dwLength = vi.num_audio_samples;
      asi.dwSampleSize = bytes_per_sample;
      wcscpy(asi.szName, L"Avisynth audio #1");
    } else {
      asi.dwScale = vi.fps_denominator;
      asi.dwRate = vi.fps_numerator;
      asi.dwLength = vi.num_frames;
      asi.rcFrame.right = vi.width;
      asi.rcFrame.bottom = vi.height;
      asi.dwSampleSize = vi.ImageSize();
      asi.dwSuggestedBufferSize = vi.ImageSize();
      wcscpy(asi.szName, L"Avisynth video #1");
    }

    memset(psi, 0, lSize);
    memcpy(psi, &asi, min(lSize, sizeof(asi)));

	return 0;
}

STDMETHODIMP_(LONG) CAVIStreamSynth::FindSample(LONG lPos, LONG lFlags) {
	_RPT3(0,"%p->CAVIStreamSynth::FindSample(%ld, %08lx)\n", this, lPos, lFlags);

	if (lFlags & FIND_FORMAT)
		return -1;

	if (lFlags & FIND_FROM_START)
		return 0;

	return lPos;
}

STDMETHODIMP CAVIStreamSynth::Read(LONG lStart, LONG lSamples, LPVOID lpBuffer, LONG cbBuffer, LONG *plBytes, LONG *plSamples) {

  _RPT3(0,"%p->CAVIStreamSynth::Read(%ld samples at %ld)\n", this, lSamples, lStart);
  _RPT2(0,"\tbuffer: %ld bytes at %p\n", cbBuffer, lpBuffer);

  if (fAudio) {

    if (lSamples == AVISTREAMREAD_CONVENIENT)
      lSamples = parent->vi.AudioSamplesFromBytes(cbBuffer);

    parent->filter_chain->GetAudio(lpBuffer, lStart, parent->vi.BytesFromAudioSamples(lSamples));
    if (plBytes) *plBytes = parent->vi.BytesFromAudioSamples(lSamples);
    if (plSamples) *plSamples = lSamples;

    return S_OK;

  } else {

    if (lSamples == AVISTREAMREAD_CONVENIENT)
      lSamples = 1;

    int image_size = parent->vi.ImageSize();

    if (plSamples) *plSamples = 1;
    if (plBytes) *plBytes = image_size;

    if (!lpBuffer) {
      return S_OK;
    } else if (cbBuffer < image_size) {
      _RPT1(0,"\tBuffer too small; should be %ld samples\n", image_size);
      return AVIERR_BUFFERTOOSMALL;
    } else {
      // we must pad out RGB scanlines to a dword boundary--annoying.
      if (parent->vi.IsRGB() && (parent->vi.width & 3)) {
        if (!myvideobuf)
          myvideobuf = new unsigned char[parent->vi.ImageSize()];
        parent->filter_chain->GetFrame(lStart, myvideobuf);
        int row_size = parent->vi.RowSize();
        int padded_row_size = (row_size+3) & ~3;
        for (int y=0; y<parent->vi.height; ++y)
          memcpy((char*)lpBuffer + y*padded_row_size, myvideobuf + y*row_size, row_size);
      } else {
        parent->filter_chain->GetFrame(lStart, (unsigned char*)lpBuffer);
      }
      return S_OK;
    }
  }
}

STDMETHODIMP CAVIStreamSynth::ReadFormat(LONG lPos, LPVOID lpFormat, LONG *lpcbFormat) {
  _RPT1(0,"%p->CAVIStreamSynth::ReadFormat()\n", this);

  if (!lpFormat) {
    *lpcbFormat = fAudio ? sizeof(WAVEFORMATEX) : sizeof(BITMAPINFOHEADER);
	  return S_OK;
  }

  memset(lpFormat, 0, *lpcbFormat);

  if (fAudio) {
    WAVEFORMATEX wfx;
    memset(&wfx, 0, sizeof(wfx));
    wfx.wFormatTag = 1;
    wfx.nChannels = parent->vi.stereo ? 2 : 1;
    wfx.nSamplesPerSec = parent->vi.audio_samples_per_second;
    wfx.wBitsPerSample = parent->vi.sixteen_bit ? 16 : 8;
    wfx.nBlockAlign = parent->vi.BytesPerAudioSample();
    wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
    memcpy(lpFormat, &wfx, min(*lpcbFormat, sizeof(wfx)));
  } else {
    BITMAPINFOHEADER bi;
    memset(&bi, 0, sizeof(bi));
    bi.biSize = sizeof(bi);
    bi.biWidth = parent->vi.width;
    bi.biHeight = parent->vi.height;
    bi.biPlanes = 1;
    bi.biBitCount = parent->vi.BitsPerPixel();
    bi.biCompression = parent->vi.IsYUY2() ? '2YUY' : BI_RGB;
    bi.biSizeImage = bi.biWidth * bi.biHeight * bi.biBitCount / 8;
    memcpy(lpFormat, &bi, min(*lpcbFormat, sizeof(bi)));
  }

  return S_OK;
}

STDMETHODIMP CAVIStreamSynth::Write(LONG lStart, LONG lSamples, LPVOID lpBuffer,
	LONG cbBuffer, DWORD dwFlags, LONG FAR *plSampWritten, 
    LONG FAR *plBytesWritten) {

	_RPT1(0,"%p->CAVIStreamSynth::Write()\n", this);

	return AVIERR_READONLY;
}