Flash ActiveX: Como carregar filme de memória ou recurso ou fluxo?

Question

Estou a incorporação de um controle ActiveX do Flash em meu aplicativo C ++ (Flash.ocx, Flash10a.ocx, etc, dependendo da sua versão do Flash).

Eu posso carregar um arquivo SWF chamando LoadMovie (0, filename), mas as necessidades de arquivo para fisicamente residir no disco. Como carregar o SWF a partir da memória (ou recurso, ou stream)? Tenho certeza de que deve haver uma maneira, porque as soluções comerciais como o f-in-box 's recurso filmes carga de flash de memória diretamente também usa controle ActiveX do flash.

Answer 1

Appearantly I um indo para necessidade de detalhes de abastecimento para um voto 'up' .. OK.

O tampão flash interno quando primeiro initiailized indica se um filme é carregado, ou se as propriedades tampão de preensão no fisrt tampão de quatro bytes.

gUfU - nenhum filme carregado. propriedades a seguir ....

FuFu -. .. tamanho [4bytes] como um número inteiro

, em seguida, o filme UNCOMPRESSED ou SWF como se fosse. Escreva uma classe IStream. encher com acima. salvar como szFile

TFlashStream *fStream = new TFlashStream(szFile);
// QI flash player


IPersistStreamInit * psStreamInit = 0;
shock->QueryInterface(::IID_IPersistStreamInit,  
                     (LPVOID*)&psStreamInit);
if(psStreamInit)
{
    psStreamInit->InitNew();
    psStreamInit->Load(fStream);
    psStreamInit->Release();
}
delete fStream;

As coisas a nota: Quando psStreamInit-> Load (fstream); vai chamar IStream :: Leia procurando o cabeçalho 'fufu'.

Se o retorno é psStreamInit correta em seguida, chama IStream :: Leia para o tamanho do buffer.

Se Everthing parece bom até agora, psStreamInit lê então em 1024 pedaços de bytes até que a leitura está esgotado. Contudo. para o cabeçalho e tamanho de arquivo.

STDMETHOD(Read)(void *pv, ULONG cb, ULONG *pcbRead)

pcbRead é inválido. você pode querer usar algo como IsBadReadPtr

-

Michael

Answer 2

Para poupar-lhe alguns digitação. Ele funciona para mim dessa maneira (não apenas trabalha extensivamente testado):

void flash_load_memory(FlashWidget* w, void* data, ULONG size) {
        FlashMemoryStream fStream = FlashMemoryStream(data, size);
        IPersistStreamInit* psStreamInit = NULL;
        w->mFlashInterface->QueryInterface(IID_IPersistStreamInit,(LPVOID*) &psStreamInit);
        if(psStreamInit) {
            psStreamInit->InitNew();
            psStreamInit->Load((LPSTREAM)&fStream);
            psStreamInit->Release();
        }
    }

class FlashMemoryStream : IStream {
    public:
        FlashMemoryStream(void* data,ULONG size) {
            this->data = data;
            this->size = size;
            this->pos = 0;
        }

        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, LPVOID* ppv) {
            return E_NOTIMPL;
        }

        ULONG STDMETHODCALLTYPE AddRef() {  
            return E_NOTIMPL;
        }

        ULONG STDMETHODCALLTYPE Release() {  
            return E_NOTIMPL;
        }

        // IStream methods
        STDMETHOD(Read) (void *pv,ULONG cb,ULONG *pcbRead) {
            if(pos == 0 && cb == 4) {
                memcpy(pv,"fUfU",4);
                pos += 4;
                return S_OK;
            }
            else if(pos == 4 && cb == 4) {
                memcpy(pv,&size,4);
                size += 8;
                pos += 4;
                return S_OK;
            }
            else {
                if(pos + cb > size) cb = size - pos;
                if(cb == 0) return S_FALSE;
                memcpy(pv,(char*)data + pos - 8,cb);
                if(pcbRead) (*pcbRead) = cb;
                pos += cb;
                return S_OK;
            }
        }

        STDMETHOD(Write) (void const *pv,ULONG cb,ULONG *pcbWritten) { return E_NOTIMPL; }
        STDMETHOD(Seek) (LARGE_INTEGER dlibMove,DWORD dwOrigin,ULARGE_INTEGER *plibNewPosition) { return E_NOTIMPL; }
        STDMETHOD(SetSize) (ULARGE_INTEGER libNewSize) { return E_NOTIMPL; }
        STDMETHOD(CopyTo) (IStream *pstm,ULARGE_INTEGER cb,ULARGE_INTEGER *pcbRead,ULARGE_INTEGER *pcbWritten) { return E_NOTIMPL; }
        STDMETHOD(Commit) (DWORD grfCommitFlags) { return E_NOTIMPL; }
        STDMETHOD(Revert) (void) { return E_NOTIMPL; }
        STDMETHOD(LockRegion) (ULARGE_INTEGER libOffset,ULARGE_INTEGER cb,DWORD dwLockType) { return E_NOTIMPL; }
        STDMETHOD(UnlockRegion) (ULARGE_INTEGER libOffset,ULARGE_INTEGER cb,DWORD dwLockType) { return E_NOTIMPL; }
        STDMETHOD(Stat) (STATSTG *pstatstg,DWORD grfStatFlag) { return E_NOTIMPL; }
        STDMETHOD(Clone) (IStream **ppstm) { return E_NOTIMPL; }

        void* data;
        ULONG size;
        ULONG pos;
    };

Answer 3

Ser um flash cara que eu não sei todos os detalhes no lado do C ++, mas se você fez um pedido no lado do Flash para um protocolo falso, no lado do C você pode interceptar esse pedido e responder-lhe com um fluxo de dados ? Quero dizer algo como:

var mc:MovieClip = createEmptyMovieClip( "mc", 0 );
mc.loadMovie( "fakeprotocol://"+filename )

Enquanto os olhares de resposta (para o Flash) como um fluxo de HTTP, que deve funcionar. (Desculpas antecipadamente se o "interceptar a solicitação e retornar um fluxo de dados" é a parte que você está pedindo ajuda.)

Answer 4

Além disso .... Flash player promove IPersistStorage. flash.QI IPersistStorage pStorage.load (mystorage_as_stream)

.. na teoria.

Infelizmente para o acima .. eu pretendia pós Flash player promove IPersistStreamInit. flash.QI IPersistStreamInit pStream.load (my_stream)

Michael

Answer 5

Este método não trabalho quando você tenta carregar um filme via MovieClipLoader ou LoadMovie de outro filme !!!

O resultado é substituir o arquivo SWF chamando !! ... de modo que este método funciona apenas para carregar o arquivo de base.

Alguém sabe um método melhor que o trabalho também com MovieClipLoader e LoadMovie? Obrigado.

Answer 6

amostra MS VC ATL (ter construído com VS 2010 SP1 + Windows SDK 7.1 e testado no Windows 7 SP1 64 bits com Flash64_11_3_300_257.ocx / Flash32_11_3_300_257.ocx e no Windows XP SP3 32 bits com Flash32_11_3_300_257.ocx):

#pragma pack(push, 1)

typedef struct _FLASH_STREAM_HEADER
{
    DWORD m_dwSignature;
    DWORD m_dwDataSize;
} FLASH_STREAM_HEADER, *PFLASH_STREAM_HEADER;

#pragma pack(pop)

static HRESULT LoadFlashMovieFromResource(ATL::CComPtr<IShockwaveFlash>& spShockwaveFlash,
    UINT nResourceID, LPCTSTR pszResourceType = RT_RCDATA)
{
    HMODULE hModule = ATL::_AtlBaseModule.GetModuleInstance();
    ATLASSUME(hModule != NULL);

    //HINSTANCE hResourceInstance = ATL::AtlFindResourceInstance(nResourceID, pszResourceType);
    //HRSRC hResource = ::FindResource(hResourceInstance, MAKEINTRESOURCE(nResourceID),
    //  pszResourceType);

    HRSRC hResource = ::FindResource(hModule, MAKEINTRESOURCE(nResourceID), pszResourceType);

    if (hResource == NULL)
        return HRESULT_FROM_WIN32(::GetLastError());

    DWORD dwResourceDataSize = ::SizeofResource(hModule, hResource);

    if (dwResourceDataSize == 0)
        return HRESULT_FROM_WIN32(::GetLastError());

    HGLOBAL hResourceLoaded = ::LoadResource(hModule, hResource);

    if (hResourceLoaded == NULL)
        return HRESULT_FROM_WIN32(::GetLastError());

    ATL::CComPtr<IStream> spStream;

    HRESULT hResult = ::CreateStreamOnHGlobal(NULL, TRUE, &spStream);

    if (FAILED(hResult))
        return hResult;

    FLASH_STREAM_HEADER fsh = {0x55665566, dwResourceDataSize};

    ULARGE_INTEGER uli = {sizeof (fsh) + dwResourceDataSize};

    hResult = spStream->SetSize(uli);

    if (FAILED(hResult))
        return hResult;

    hResult = spStream->Write(&fsh, sizeof (fsh), NULL);

    if (FAILED(hResult))
        return hResult;

    hResult = spStream->Write(reinterpret_cast<void*>(hResourceLoaded), dwResourceDataSize, NULL);

    if (FAILED(hResult))
        return hResult;

    uli.QuadPart = 0;

    hResult = spStream->Seek(*reinterpret_cast<PLARGE_INTEGER>(&uli), STREAM_SEEK_SET, NULL);

    if (FAILED(hResult))
        return hResult;

    ATL::CComPtr<IPersistStreamInit> spPersistStreamInit;

    hResult = spShockwaveFlash.QueryInterface(&spPersistStreamInit);

    if (SUCCEEDED(hResult))
        hResult = spPersistStreamInit->Load(spStream);

    return hResult;
}