# HG changeset patch # User rtognimp # Date 1104349916 0 # Node ID fa80ed52127b752bb994a0aaa9fc47765f25d768 # Parent de13fd55744061411a70b385bbbbccb6e966a12f TwinVQ decoder and demuxer diff -r de13fd557440 -r fa80ed52127b etc/codecs.conf --- a/etc/codecs.conf Wed Dec 29 19:50:44 2004 +0000 +++ b/etc/codecs.conf Wed Dec 29 19:51:56 2004 +0000 @@ -2475,3 +2475,10 @@ format 0x1104 ; SBC driver acm dll "lhacm.acm" + +audiocodec TwinVQ + info "VQF codec by NTTLabs" + status working + fourcc TWIN + driver vqf + dll "tvqdec.dll" diff -r de13fd557440 -r fa80ed52127b libmpcodecs/Makefile --- a/libmpcodecs/Makefile Wed Dec 29 19:50:44 2004 +0000 +++ b/libmpcodecs/Makefile Wed Dec 29 19:51:56 2004 +0000 @@ -6,7 +6,7 @@ AUDIO_SRCS_LIB=ad_liba52.c ad_hwac3.c ad_mp3lib.c AUDIO_SRCS_NAT=ad_alaw.c ad_dk3adpcm.c ad_pcm.c ad_dvdpcm.c ad_imaadpcm.c ad_msadpcm.c ad_msgsm.c ad_ra1428.c -AUDIO_SRCS_OPT=ad_acm.c ad_dshow.c ad_dmo.c ad_qtaudio.c ad_ffmpeg.c ad_faad.c ad_libvorbis.c ad_libmad.c ad_realaud.c ad_libdv.c +AUDIO_SRCS_OPT=ad_acm.c ad_dshow.c ad_dmo.c ad_qtaudio.c ad_ffmpeg.c ad_faad.c ad_libvorbis.c ad_libmad.c ad_realaud.c ad_libdv.c ad_twin.c AUDIO_SRCS=dec_audio.c ad.c $(AUDIO_SRCS_LIB) $(AUDIO_SRCS_NAT) $(AUDIO_SRCS_OPT) VIDEO_SRCS_LIB=vd_libmpeg2.c vd_nuv.c vd_lzo.c diff -r de13fd557440 -r fa80ed52127b libmpcodecs/ad.c --- a/libmpcodecs/ad.c Wed Dec 29 19:50:44 2004 +0000 +++ b/libmpcodecs/ad.c Wed Dec 29 19:51:56 2004 +0000 @@ -38,6 +38,7 @@ extern ad_functions_t mpcodecs_ad_libdv; extern ad_functions_t mpcodecs_ad_qtaudio; extern ad_functions_t mpcodecs_ad_ra1428; +extern ad_functions_t mpcodecs_ad_twin; ad_functions_t* mpcodecs_ad_drivers[] = { @@ -65,6 +66,7 @@ &mpcodecs_ad_dmo, #endif &mpcodecs_ad_acm, + &mpcodecs_ad_twin, #endif #if defined(USE_QTX_CODECS) || defined(MACOSX) &mpcodecs_ad_qtaudio, diff -r de13fd557440 -r fa80ed52127b libmpcodecs/ad_twin.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libmpcodecs/ad_twin.c Wed Dec 29 19:51:56 2004 +0000 @@ -0,0 +1,510 @@ +#include +#include +#include +#include "config.h" + +#ifdef USE_WIN32DLL + +#include "ad_internal.h" +#include "vqf.h" +#include "../../loader/ldt_keeper.h" +#include "wine/windef.h" +#include "../libaf/af_format.h" + +#include "help_mp.h" + +static ad_info_t info = +{ + "TWinVQ decoder", + "vqf", + "Roberto Togni", + "Nick Kurshev", + "Ported from MPlayerXP" +}; + +LIBAD_EXTERN(twin) + +void* WINAPI LoadLibraryA(char* name); +void* WINAPI GetProcAddress(void* handle, char* func); +int WINAPI FreeLibrary(void* handle); + +static int (*TvqInitialize)( headerInfo *setupInfo, INDEX *index, int dispErrorMessageBox ); +static void (*TvqTerminate)( INDEX *index ); +static void (*TvqGetVectorInfo)(int *bits0[], int *bits1[]); + +static void (*TvqDecodeFrame)(INDEX *indexp, float out[]); +static int (*TvqWtypeToBtype)( int w_type, int *btype ); +static void (*TvqUpdateVectorInfo)(int varbits, int *ndiv, int bits0[], int bits1[]); + +static int (*TvqCheckVersion)(char *versionID); +static void (*TvqGetConfInfo)(tvqConfInfo *cf); +static int (*TvqGetFrameSize)(); +static int (*TvqGetNumFixedBitsPerFrame)(); + +#define BYTE_BIT 8 +#define BBUFSIZ 1024 /* Bit buffer size (bytes) */ +#define BBUFLEN (BBUFSIZ*BYTE_BIT) /* Bit buffer length (bits) */ +typedef struct vqf_priv_s +{ + float pts; + WAVEFORMATEX o_wf; // out format + INDEX index; + tvqConfInfo cf; + headerInfo hi; + int *bits_0[N_INTR_TYPE], *bits_1[N_INTR_TYPE]; + unsigned framesize; + /* stream related */ + int readable; + int ptr; /* current point in the bit buffer */ + int nbuf; /* bit buffer size */ + char buf[BBUFSIZ]; /* the bit buffer */ + int skip_cnt; +}vqf_priv_t; + +static void* vqf_dll; + +static int load_dll( char *libname ) +{ +#ifdef WIN32_LOADER + Setup_LDT_Keeper(); +#endif + vqf_dll = LoadLibraryA(libname); + if( vqf_dll == NULL ) + { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "failed loading dll\n" ); + return 0; + } + TvqInitialize = GetProcAddress(vqf_dll,"TvqInitialize"); + TvqTerminate = GetProcAddress(vqf_dll,"TvqTerminate"); + TvqGetVectorInfo = GetProcAddress(vqf_dll,"TvqGetVectorInfo"); + TvqDecodeFrame = GetProcAddress(vqf_dll,"TvqDecodeFrame"); + TvqWtypeToBtype = GetProcAddress(vqf_dll,"TvqWtypeToBtype"); + TvqUpdateVectorInfo = GetProcAddress(vqf_dll,"TvqUpdateVectorInfo"); + TvqCheckVersion = GetProcAddress(vqf_dll,"TvqCheckVersion"); + TvqGetConfInfo = GetProcAddress(vqf_dll,"TvqGetConfInfo"); + TvqGetFrameSize = GetProcAddress(vqf_dll,"TvqGetFrameSize"); + TvqGetNumFixedBitsPerFrame = GetProcAddress(vqf_dll,"TvqGetNumFixedBitsPerFrame"); + return TvqInitialize && TvqTerminate && TvqGetVectorInfo && + TvqDecodeFrame && TvqWtypeToBtype && TvqUpdateVectorInfo && + TvqCheckVersion && TvqGetConfInfo && TvqGetFrameSize && + TvqGetNumFixedBitsPerFrame; +} + +extern void print_wave_header(WAVEFORMATEX *h); +static int init_vqf_audio_codec(sh_audio_t *sh_audio){ + WAVEFORMATEX *in_fmt=sh_audio->wf; + vqf_priv_t*priv=sh_audio->context; + int ver; + mp_msg(MSGT_DECAUDIO, MSGL_INFO, "======= Win32 (TWinVQ) AUDIO Codec init =======\n"); + + sh_audio->channels=in_fmt->nChannels; + sh_audio->samplerate=in_fmt->nSamplesPerSec; + sh_audio->sample_format=AF_FORMAT_S16_NE; +// sh_audio->sample_format=AF_FORMAT_FLOAT_NE; + sh_audio->samplesize=af_fmt2bits(sh_audio->sample_format)/8; + priv->o_wf.nChannels=in_fmt->nChannels; + priv->o_wf.nSamplesPerSec=in_fmt->nSamplesPerSec; + priv->o_wf.nBlockAlign=sh_audio->samplesize*in_fmt->nChannels; + priv->o_wf.nAvgBytesPerSec=in_fmt->nBlockAlign*in_fmt->nChannels; + priv->o_wf.wFormatTag=0x01; + priv->o_wf.wBitsPerSample=in_fmt->wBitsPerSample; + priv->o_wf.cbSize=0; + + if(verbose) + { + mp_msg(MSGT_DECAUDIO, MSGL_INFO, "Input format:\n"); + print_wave_header(in_fmt); + mp_msg(MSGT_DECAUDIO, MSGL_INFO, "Output fmt:\n"); + print_wave_header(&priv->o_wf); + } + memcpy(&priv->hi,&in_fmt[1],sizeof(headerInfo)); + if((ver=TvqInitialize(&priv->hi,&priv->index,0))){ + const char *tvqe[]={ + "No errors", + "General error", + "Wrong version", + "Channel setting error", + "Wrong coding mode", + "Inner parameter setting error", + "Wrong number of VQ pre-selection candidates, used only in encoder" }; + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "Tvq initialization error: %s\n",ver>=0&&ver<7?tvqe[ver]:"Unknown"); + return 0; + } + ver=TvqCheckVersion(priv->hi.ID); + if(ver==TVQ_UNKNOWN_VERSION){ + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "Tvq unknown version of stream\n" ); + return 0; + } + TvqGetConfInfo(&priv->cf); + TvqGetVectorInfo(priv->bits_0,priv->bits_1); + priv->framesize=TvqGetFrameSize(); + sh_audio->audio_in_minsize=priv->framesize*in_fmt->nChannels; + sh_audio->a_in_buffer_size=4*sh_audio->audio_in_minsize; + sh_audio->a_in_buffer=malloc(sh_audio->a_in_buffer_size); + sh_audio->a_in_buffer_len=0; + + + return 1; +} + +static int close_vqf_audio_codec(sh_audio_t *sh_audio) +{ + vqf_priv_t*priv=sh_audio->context; + TvqTerminate(&priv->index); + return 1; +} + +int init(sh_audio_t *sh_audio) +{ + return 1; +} + +int preinit(sh_audio_t *sh_audio) +{ + /* Win32 VQF audio codec: */ + vqf_priv_t *priv; + if(!(sh_audio->context=malloc(sizeof(vqf_priv_t)))) return 0; + priv=sh_audio->context; + if(!load_dll(sh_audio->codec->dll)) + { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "win32.dll looks broken :(\n"); + return 0; + } + if(!init_vqf_audio_codec(sh_audio)){ + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "TWinVQ initialization fail\n"); + return 0; + } + mp_msg(MSGT_DECAUDIO, MSGL_INFO, "INFO: TWinVQ (%s) audio codec init OK!\n",sh_audio->codec->dll); + priv->skip_cnt = 2; + return 1; +} + +void uninit(sh_audio_t *sh) +{ + close_vqf_audio_codec(sh); + free(sh->context); + FreeLibrary(vqf_dll); +} + +int control(sh_audio_t *sh_audio,int cmd,void* arg, ...) +{ + switch(cmd) { + case ADCTRL_QUERY_FORMAT: + return CONTROL_TRUE; + default: + return CONTROL_UNKNOWN; + } +} + +static int bread(char *data, /* Output: Output data array */ + int size, /* Input: Length of each data */ + int nbits, /* Input: Number of bits to write */ + sh_audio_t *sh) /* Input: File pointer */ +{ + /*--- Variables ---*/ + int ibits, iptr, idata, ibufadr, ibufbit, icl; + unsigned char mask, tmpdat; + int retval; + vqf_priv_t *priv=sh->context; + + /*--- Main operation ---*/ + retval = 0; + mask = 0x1; + for ( ibits=0; ibitsreadable == 0 ){ /* when the file data buffer is empty */ + priv->nbuf = demux_read_data(sh->ds, priv->buf, BBUFSIZ); + priv->nbuf *= 8; + priv->readable = 1; + } + iptr = priv->ptr; /* current file data buffer pointer */ + if ( iptr >= priv->nbuf ) /* If data file is empty then return */ + return(retval); + ibufadr = iptr/BYTE_BIT; /* current file data buffer address */ + ibufbit = iptr%BYTE_BIT; /* current file data buffer bit */ + /* tmpdat = stream->buf[ibufadr] >> (BYTE_BIT-ibufbit-1); */ + tmpdat = (unsigned char)priv->buf[ibufadr]; + tmpdat >>= (BYTE_BIT-ibufbit-1); + /* current data bit */ + + idata = ibits*size; /* output data address */ + data[idata] = (char)(tmpdat & mask); /* set output data */ + for (icl=1; iclptr += 1; /* update data buffer pointer */ + if (priv->ptr == BBUFLEN){ + priv->ptr = 0; + priv->readable = 0; + } + ++retval; + } + return(retval); +} + +#define BITS_INT (sizeof(int)*8) + +static int get_bstm(int *data, /* Input: input data */ + unsigned nbits, /* Input: number of bits */ + sh_audio_t *sh) /* Input: bit file pointer */ +{ + unsigned ibit; + unsigned mask; + unsigned work; + char tmpbit[BITS_INT]; + int retval; + + if ( nbits > BITS_INT ){ + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "get_bstm(): %d: %d Error.\n", + nbits, BITS_INT); + exit(1); + } + retval = bread(tmpbit, sizeof(*tmpbit), nbits, sh); + for (ibit=retval; ibit>= 1; + } + *data = work; + return(retval); +} + +static int GetVqInfo( tvqConfInfoSubBlock *cfg, + int bits0[], + int bits1[], + int variableBits, + INDEX *index, + sh_audio_t *sh) +{ + int idiv; + int bitcount = 0; + + if ( index->btype == BLK_LONG ){ + TvqUpdateVectorInfo( variableBits, &cfg->ndiv, bits0, bits1 ); // re-calculate VQ bits + } + for ( idiv=0; idivndiv; idiv++ ){ + bitcount += get_bstm(&index->wvq[idiv],bits0[idiv],sh); /* CB 0 */ + bitcount += get_bstm(&index->wvq[idiv+cfg->ndiv],bits1[idiv],sh); /* CB 1 */ + } + return bitcount; +} + +static int GetBseInfo( tvqConfInfo *cf, tvqConfInfoSubBlock *cfg, INDEX *index, sh_audio_t *sh) +{ + int i_sup, isf, itmp, idiv; + int bitcount = 0; + + for ( i_sup=0; i_supN_CH; i_sup++ ){ + for ( isf=0; isfnsf; isf++ ){ + for ( idiv=0; idivfw_ndiv; idiv++ ){ + itmp = idiv + ( isf + i_sup * cfg->nsf ) * cfg->fw_ndiv; + bitcount += get_bstm(&index->fw[itmp],cfg->fw_nbit,sh); + } + } + } + for ( i_sup=0; i_supN_CH; i_sup++ ){ + for ( isf=0; isfnsf; isf++ ){ + bitcount += get_bstm(&index->fw_alf[i_sup * cfg->nsf + isf],cf->FW_ARSW_BITS,sh); + } + } + return bitcount; +} + +static int GetGainInfo(tvqConfInfo *cf, tvqConfInfoSubBlock *cfg, INDEX *index, sh_audio_t *sh ) +{ + int i_sup, iptop, isf; + int bitcount = 0; + + for ( i_sup=0; i_supN_CH; i_sup++ ){ + iptop = ( cfg->nsubg + 1 ) * i_sup; + bitcount += get_bstm(&index->pow[iptop], cf->GAIN_BITS,sh); + for ( isf=0; isfnsubg; isf++ ){ + bitcount += get_bstm(&index->pow[iptop+isf+1], cf->SUB_GAIN_BITS,sh); + } + } + return bitcount; +} + +static int GetLspInfo( tvqConfInfo *cf, INDEX *index, sh_audio_t *sh ) +{ + int i_sup, itmp; + int bitcount = 0; + + for ( i_sup=0; i_supN_CH; i_sup++ ){ + bitcount += get_bstm(&index->lsp[i_sup][0], cf->LSP_BIT0,sh); /* pred. switch */ + bitcount += get_bstm(&index->lsp[i_sup][1], cf->LSP_BIT1,sh); /* first stage */ + for ( itmp=0; itmpLSP_SPLIT; itmp++ ){ /* second stage */ + bitcount += get_bstm(&index->lsp[i_sup][itmp+2], cf->LSP_BIT2,sh); + } + } + + return bitcount; +} + +static int GetPpcInfo( tvqConfInfo *cf, INDEX *index, sh_audio_t *sh) +{ + int idiv, i_sup; + int bitcount = 0; + vqf_priv_t*priv=sh->context; + + for ( idiv=0; idivN_DIV_P; idiv++ ){ + bitcount += get_bstm(&(index->pls[idiv]), priv->bits_0[BLK_PPC][idiv],sh); /*CB0*/ + bitcount += get_bstm(&(index->pls[idiv+cf->N_DIV_P]), priv->bits_1[BLK_PPC][idiv],sh);/*CB1*/ + } + for (i_sup=0; i_supN_CH; i_sup++){ + bitcount += get_bstm(&(index->pit[i_sup]), cf->BASF_BIT,sh); + bitcount += get_bstm(&(index->pgain[i_sup]), cf->PGAIN_BIT,sh); + } + + return bitcount; +} + +static int GetEbcInfo( tvqConfInfo *cf, tvqConfInfoSubBlock *cfg, INDEX *index, sh_audio_t *sh) +{ + int i_sup, isf, itmp; + int bitcount = 0; + + for ( i_sup=0; i_supN_CH; i_sup++ ){ + for ( isf=0; isfnsf; isf++){ + int indexSfOffset = isf * ( cfg->ncrb - cfg->ebc_crb_base ) - cfg->ebc_crb_base; + for ( itmp=cfg->ebc_crb_base; itmpncrb; itmp++ ){ + bitcount += get_bstm(&index->bc[i_sup][itmp+indexSfOffset], cfg->ebc_bits,sh); + } + } + } + + return bitcount; +} + +static int vqf_read_frame(sh_audio_t *sh,INDEX *index) +{ + /*--- Variables ---*/ + tvqConfInfoSubBlock *cfg; + int variableBits; + int bitcount; + int numFixedBitsPerFrame = TvqGetNumFixedBitsPerFrame(); + int btype; + vqf_priv_t *priv=sh->context; + + /*--- Initialization ---*/ + variableBits = 0; + bitcount = 0; + + /*--- read block independent factors ---*/ + /* Window type */ + bitcount += get_bstm( &index->w_type, priv->cf.BITS_WTYPE, sh ); + if ( TvqWtypeToBtype( index->w_type, &index->btype ) ) { + mp_msg(MSGT_DECAUDIO, MSGL_ERR, "Error: unknown window type: %d\n", index->w_type); + return 0; + } + btype = index->btype; + + /*--- read block dependent factors ---*/ + cfg = &priv->cf.cfg[btype]; // set the block dependent paremeters table + + bitcount += variableBits; + + /* Interleaved vector quantization */ + bitcount += GetVqInfo( cfg, priv->bits_0[btype], priv->bits_1[btype], variableBits, index, sh ); + + /* Bark-scale envelope */ + bitcount += GetBseInfo( &priv->cf, cfg, index, sh ); + /* Gain */ + bitcount += GetGainInfo( &priv->cf, cfg, index, sh ); + /* LSP */ + bitcount += GetLspInfo( &priv->cf, index, sh ); + /* PPC */ + if ( cfg->ppc_enable ){ + bitcount += GetPpcInfo( &priv->cf, index, sh ); + } + /* Energy Balance Calibration */ + if ( cfg->ebc_enable ){ + bitcount += GetEbcInfo( &priv->cf, cfg, index, sh ); + } + + return bitcount == numFixedBitsPerFrame ? bitcount/8 : 0; +} + +static void frtobuf_s16(float out[], /* Input --- input data frame */ + short bufout[], /* Output --- output data buffer array */ + unsigned frameSize, /* Input --- frame size */ + unsigned numChannels) /* Input --- number of channels */ +{ + /*--- Variables ---*/ + unsigned ismp, ich; + float *ptr; + float dtmp; + + for ( ich=0; ich= 0. ) { + if ( dtmp > 32700. ) + dtmp = 32700.; + bufout[ismp*numChannels+ich] = (short)(dtmp+0.5); + } else { + if ( dtmp < -32700. ) + dtmp = -32700.; + bufout[ismp*numChannels+ich] = (short)(dtmp-0.5); + } + } + } +} + +static void frtobuf_float(float out[], /* Input --- input data frame */ + float bufout[], /* Output --- output data buffer array */ + unsigned frameSize, /* Input --- frame size */ + unsigned numChannels) /* Input --- number of channels */ +{ + /*--- Variables ---*/ + unsigned ismp, ich; + float *ptr; + float dtmp; + + for ( ich=0; ich= 0. ) { + if ( dtmp > 32700. ) + dtmp = 32700.; + bufout[ismp*numChannels+ich] = dtmp/32767.; + } else { + if ( dtmp < -32700. ) + dtmp = -32700.; + bufout[ismp*numChannels+ich] = dtmp/32767.; + } + } + } +} + +int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen) +{ + int l, len=0; + vqf_priv_t *priv=sh_audio->context; + while(lenframesize*sh_audio->channels]; + l=vqf_read_frame(sh_audio,&priv->index); + if(!l) break; + TvqDecodeFrame(&priv->index, out); + if (priv->skip_cnt) { + // Ingnore first two frames, replace them with silence + priv->skip_cnt--; + memset(buf, 0, priv->framesize*sh_audio->channels*sh_audio->samplesize); + } else { + if (sh_audio->sample_format == AF_FORMAT_S16_NE) + frtobuf_s16(out, (short *)buf, priv->framesize, sh_audio->channels); + else + frtobuf_float(out, (float *)buf, priv->framesize, sh_audio->channels); + } + len += priv->framesize*sh_audio->channels*sh_audio->samplesize; + buf += priv->framesize*sh_audio->channels*sh_audio->samplesize; + } + return len; +} + +#endif diff -r de13fd557440 -r fa80ed52127b libmpcodecs/vqf.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libmpcodecs/vqf.h Wed Dec 29 19:51:56 2004 +0000 @@ -0,0 +1,226 @@ +/* (c)Copyright 1996-2000 NTT Cyber Space Laboratories */ +/* Released on 2000.05.22 by N. Iwakami */ +/* Modified on 2000.05.25 by N. Iwakami */ +/* Released on 2000.09.06 by N. Iwakami */ + +// Modified for MPlayer on 2004.12.29 + +#ifndef tvqdec_h +#define tvqdec_h + +#ifdef _MSC_VER +# ifdef DLL_MODULE +# define DllPort __declspec( dllexport ) +# else +# define DllPort __declspec( dllimport ) +# endif +#else +# define DllPort +#endif + +#ifdef __cplusplus +extern "C" { // only need to import/export C interface if used by C++ source code +#endif + +/************************/ +/*** General settings ***/ +/************************/ +/* Initialization error code */ +enum INIT_ERROR_CODE { + TVQ_NO_ERROR = 0, // no error + TVQ_ERROR, // general + TVQ_ERROR_VERSION, // wrong version + TVQ_ERROR_CHANNEL, // channel setting error + TVQ_ERROR_MODE, // wrong coding mode + TVQ_ERROR_PARAM, // inner parameter setting error + TVQ_ERROR_N_CAN, // wrong number of VQ pre-selection candidates, used only in encoder +}; + +/* version ID */ +#define TVQ_UNKNOWN_VERSION -1 +#define V2 0 +#define V2PP 1 + +#define N_VERSIONS 2 + +/* window types */ +enum WINDOW_TYPE { + ONLY_LONG_WINDOW = 0, + LONG_SHORT_WINDOW, + ONLY_SHORT_WINDOW, + SHORT_LONG_WINDOW, + SHORT_MEDIUM_WINDOW, + MEDIUM_LONG_WINDOW, + LONG_MEDIUM_WINDOW, + MEDIUM_SHORT_WINDOW, + ONLY_MEDIUM_WINDOW, +}; + +/* block types */ +enum BLOCK_TYPE { + BLK_SHORT = 0, + BLK_MEDIUM, + BLK_LONG, + BLK_PPC, +}; +#define N_BTYPE 3 // number of block types +#define N_INTR_TYPE 4 // number of interleave types, enum BLOCK_TYPE is commonly used for detecting interleave types. + +/* maximum number of channels */ +#define N_CH_MAX 2 + +/* type definition of code information interface */ +typedef struct { + /* block type */ + int w_type; + int btype; + + /* FBC info */ + int *segment_sw[ N_CH_MAX ]; + int *band_sw[ N_CH_MAX ]; + int *fg_intensity[ N_CH_MAX ]; + + /* VQ info */ + int *wvq; + + /* BSE info */ + int *fw; + int *fw_alf; + + /* gain info */ + int *pow; + + /* LSP info */ + int *lsp[ N_CH_MAX ]; + + /* PPC info */ + int pit[ N_CH_MAX ]; + int *pls; + int pgain[ N_CH_MAX ]; + + /* EBC info */ + int *bc[ N_CH_MAX ]; + + void *manager; +} INDEX; + +/***********************************************/ +/*** Definitions about program configuration ***/ +/***********************************************/ +/* type definition of tvqConfInfoSubBlock */ +typedef struct { + int sf_sz; // subframe size + int nsf; // number of subframes + int ndiv; // number of division of weighted interleave vector quantization + int ncrb; // number of Bark-scale subbands + int fw_ndiv; // number of division of BSE VQ + int fw_nbit; // number of bits for BSE VQ + int nsubg; // number of sub-blocks for gain coding + int ppc_enable; // PPC switch + int ebc_enable; // EBC switch + int ebc_crb_base; // EBC base band + int ebc_bits; // EBC bits + int fbc_enable; // FBC switch + int fbc_n_segment; // FBC number of segments + int fbc_nband; // FBC number of subbands + int *fbc_crb_tbl; // FBC subband table +} tvqConfInfoSubBlock; + +/* type definition of tvqConfInfo */ +typedef struct { + /* frame configuration */ + int N_CH; + /* window type coding */ + int BITS_WTYPE; + /* LSP coding */ + int LSP_BIT0; + int LSP_BIT1; + int LSP_BIT2; + int LSP_SPLIT; + /* Bark-scale envelope coding */ + int FW_ARSW_BITS; + /* gain coding */ + int GAIN_BITS; + int SUB_GAIN_BITS; + /* pitch excitation */ + int N_DIV_P; + int BASF_BIT; + int PGAIN_BIT; + + /* block type dependent parameters */ + tvqConfInfoSubBlock cfg[N_BTYPE]; + +} tvqConfInfo; + + +/*************************************************/ +/*** Definitions about TwinVQ bitstream header ***/ +/*************************************************/ +//#include "../declib_src/tvq_hdr.h" +//#ifndef BUFSIZ +//#define BUFSIZ 1024 +//#endif + +#define KEYWORD_BYTES 4 +#define VERSION_BYTES 8 +#define ELEM_BYTES sizeof(unsigned long) + + +/* + */ +typedef struct { + char ID[KEYWORD_BYTES+VERSION_BYTES+1]; + int size; + /* Common Chunk */ + int channelMode; /* channel mode (mono:0/stereo:1) */ + int bitRate; /* bit rate (kbit/s) */ + int samplingRate; /* sampling rate (44.1 kHz -> 44) */ + int securityLevel; /* security level (always 0) */ + /* Text Chunk */ + char Name[BUFSIZ]; + char Comt[BUFSIZ]; + char Auth[BUFSIZ]; + char Cpyr[BUFSIZ]; + char File[BUFSIZ]; + char Extr[BUFSIZ]; // add by OKAMOTO 99.12.21 + /* Data size chunk*/ + int Dsiz; +} headerInfo; + +// TwinVQ decoder initialization/termination functions +//DllPort int TvqInitialize( headerInfo *setupInfo, INDEX *index, int dispErrorMessageBox ); +//DllPort void TvqTerminate( INDEX *index ); +//DllPort void TvqGetVectorInfo(int *bits0[], int *bits1[]); +//DllPort void TvqResetFrameCounter(); + +// TwinVQ decoder function +//DllPort void TvqDecodeFrame(INDEX *indexp, float out[]); +//DllPort int TvqWtypeToBtype( int w_type, int *btype ); +//DllPort void TvqUpdateVectorInfo(int varbits, int *ndiv, int bits0[], int bits1[]); +//DllPort void TvqSetFrameCounter( int position ); + +// TwinVQ query functions +//DllPort int TvqCheckVersion(char *versionID); +//DllPort void TvqGetSetupInfo(headerInfo *setupInfo); // setup information +//DllPort void TvqGetConfInfo(tvqConfInfo *cf); // configuration information +//DllPort int TvqGetFrameSize(); // frame size +//DllPort int TvqGetNumChannels(); // number of channels +//DllPort int TvqGetBitRate(); // total bitrate +//DllPort float TvqGetSamplingRate(); // sampling rate +//DllPort int TvqGetNumFixedBitsPerFrame(); // number of fixed bits per frame +//DllPort int TvqGetNumFrames(); // number of decoded frame +//DllPort int TvqGetModuleVersion( char* versionString ); + +#ifdef V2PLUS_SUPPORT +// TwinVQ FB coding tool control +DllPort void TvqFbCountUsedBits(int nbit); // count number of used bits +DllPort float TvqGetFbCurrentBitrate(); // query average bitrate for the tool +DllPort int TvqGetFbTotalBits(); // query total number of used bits +#endif + +#ifdef __cplusplus +} +#endif + + +#endif diff -r de13fd557440 -r fa80ed52127b libmpdemux/Makefile --- a/libmpdemux/Makefile Wed Dec 29 19:50:44 2004 +0000 +++ b/libmpdemux/Makefile Wed Dec 29 19:51:56 2004 +0000 @@ -3,7 +3,7 @@ include ../config.mak -SRCS = mp3_hdr.c video.c mpeg_hdr.c cache2.c asfheader.c aviheader.c aviprint.c muxer.c muxer_avi.c muxer_mpeg.c demux_asf.c demux_avi.c demux_mov.c parse_mp4.c demux_mpg.c demux_ty.c demux_ty_osd.c demux_pva.c demux_viv.c demuxer.c dvdnav_stream.c open.c parse_es.c stream.c stream_file.c stream_netstream.c stream_vcd.c stream_null.c stream_ftp.c tv.c tvi_dummy.c tvi_v4l.c tvi_v4l2.c tvi_bsdbt848.c frequencies.c demux_fli.c demux_real.c demux_y4m.c yuv4mpeg.c yuv4mpeg_ratio.c demux_nuv.c demux_film.c demux_roq.c mf.c demux_mf.c demux_audio.c demux_demuxers.c demux_ogg.c cdda.c demux_rawaudio.c demux_rawvideo.c cddb.c cdinfo.c demux_rawdv.c ai_alsa.c ai_alsa1x.c ai_oss.c audio_in.c demux_smjpeg.c demux_lmlm4.c cue_read.c extension.c demux_gif.c demux_ts.c demux_realaud.c url.c muxer_rawvideo.c demux_lavf.c demux_nsv.c +SRCS = mp3_hdr.c video.c mpeg_hdr.c cache2.c asfheader.c aviheader.c aviprint.c muxer.c muxer_avi.c muxer_mpeg.c demux_asf.c demux_avi.c demux_mov.c parse_mp4.c demux_mpg.c demux_ty.c demux_ty_osd.c demux_pva.c demux_viv.c demuxer.c dvdnav_stream.c open.c parse_es.c stream.c stream_file.c stream_netstream.c stream_vcd.c stream_null.c stream_ftp.c tv.c tvi_dummy.c tvi_v4l.c tvi_v4l2.c tvi_bsdbt848.c frequencies.c demux_fli.c demux_real.c demux_y4m.c yuv4mpeg.c yuv4mpeg_ratio.c demux_nuv.c demux_film.c demux_roq.c mf.c demux_mf.c demux_audio.c demux_demuxers.c demux_ogg.c cdda.c demux_rawaudio.c demux_rawvideo.c cddb.c cdinfo.c demux_rawdv.c ai_alsa.c ai_alsa1x.c ai_oss.c audio_in.c demux_smjpeg.c demux_lmlm4.c cue_read.c extension.c demux_gif.c demux_ts.c demux_realaud.c url.c muxer_rawvideo.c demux_lavf.c demux_nsv.c demux_vqf.c ifeq ($(XMMS_PLUGINS),yes) SRCS += demux_xmms.c endif diff -r de13fd557440 -r fa80ed52127b libmpdemux/demux_vqf.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libmpdemux/demux_vqf.c Wed Dec 29 19:51:56 2004 +0000 @@ -0,0 +1,201 @@ +#include "config.h" + +#include +#include +#include "bswap.h" + +#include "stream.h" +#include "demuxer.h" +#include "stheader.h" +#include "../libmpcodecs/vqf.h" + +extern void resync_audio_stream(sh_audio_t *sh_audio); + +int demux_probe_vqf(demuxer_t* demuxer) +{ + char buf[KEYWORD_BYTES]; + stream_t *s; + s = demuxer->stream; + stream_read(s,buf,KEYWORD_BYTES); + if(memcmp(buf,"TWIN",KEYWORD_BYTES)==0) return 1; /*version: 97012000*/ + return 0; +} + +demuxer_t* demux_open_vqf(demuxer_t* demuxer) { + sh_audio_t* sh_audio; + WAVEFORMATEX* w; + stream_t *s; + headerInfo *hi; + + s = demuxer->stream; + + sh_audio = new_sh_audio(demuxer,0); + sh_audio->wf = w = (WAVEFORMATEX*)malloc(sizeof(WAVEFORMATEX)+sizeof(headerInfo)); + hi = (headerInfo *)&w[1]; + memset(hi,0,sizeof(headerInfo)); + w->wFormatTag = 0x1; + sh_audio->format = mmioFOURCC('T','W','I','N'); /* TWinVQ */ + w->nChannels = sh_audio->channels = 2; + w->nSamplesPerSec = sh_audio->samplerate = 44100; + w->nAvgBytesPerSec = w->nSamplesPerSec*sh_audio->channels*2; + w->nBlockAlign = 0; + sh_audio->samplesize = 2; + w->wBitsPerSample = 8*sh_audio->samplesize; + w->cbSize = 0; + strcpy(hi->ID,"TWIN"); + stream_read(s,hi->ID+KEYWORD_BYTES,VERSION_BYTES); /* fourcc+version_id */ + while(1) + { + char chunk_id[4]; + unsigned chunk_size; + hi->size=chunk_size=stream_read_dword(s); /* include itself */ + stream_read(s,chunk_id,4); + if(*((uint32_t *)&chunk_id[0])==mmioFOURCC('C','O','M','M')) + { + char buf[chunk_size-8]; + unsigned i,subchunk_size; + if(stream_read(s,buf,chunk_size-8)!=chunk_size-8) return NULL; + i=0; + subchunk_size=be2me_32(*((uint32_t *)&buf[0])); + hi->channelMode=be2me_32(*((uint32_t *)&buf[4])); + w->nChannels=sh_audio->channels=hi->channelMode+1; /*0-mono;1-stereo*/ + hi->bitRate=be2me_32(*((uint32_t *)&buf[8])); + sh_audio->i_bps=hi->bitRate*1000/8; /* bitrate kbit/s */ + w->nAvgBytesPerSec = sh_audio->i_bps; + hi->samplingRate=be2me_32(*((uint32_t *)&buf[12])); + switch(hi->samplingRate){ + case 44: + w->nSamplesPerSec=44100; + break; + case 22: + w->nSamplesPerSec=22050; + break; + case 11: + w->nSamplesPerSec=11025; + break; + default: + w->nSamplesPerSec=hi->samplingRate*1000; + break; + } + sh_audio->samplerate=w->nSamplesPerSec; + hi->securityLevel=be2me_32(*((uint32_t *)&buf[16])); + w->nBlockAlign = 0; + sh_audio->samplesize = 4; + w->wBitsPerSample = 8*sh_audio->samplesize; + w->cbSize = 0; + i+=subchunk_size+4; + while(iDsiz=be2me_32(*((uint32_t *)&buf[i])); + continue; /* describes the same info as size of DATA chunk */ + } + memcpy(sdata,&buf[i],slen); sdata[slen]=0; i+=slen; + if(sid==mmioFOURCC('N','A','M','E')) + { + memcpy(hi->Name,sdata,min(BUFSIZ,slen)); + demux_info_add(demuxer,"Title",sdata); + } + else + if(sid==mmioFOURCC('A','U','T','H')) + { + memcpy(hi->Auth,sdata,min(BUFSIZ,slen)); + demux_info_add(demuxer,"Author",sdata); + } + else + if(sid==mmioFOURCC('C','O','M','T')) + { + memcpy(hi->Comt,sdata,min(BUFSIZ,slen)); + demux_info_add(demuxer,"Comment",sdata); + } + else + if(sid==mmioFOURCC('(','c',')',' ')) + { + memcpy(hi->Cpyr,sdata,min(BUFSIZ,slen)); + demux_info_add(demuxer,"Copyright",sdata); + } + else + if(sid==mmioFOURCC('F','I','L','E')) + { + memcpy(hi->File,sdata,min(BUFSIZ,slen)); + } + else + if(sid==mmioFOURCC('A','L','B','M')) demux_info_add(demuxer,"Album",sdata); + else + if(sid==mmioFOURCC('Y','E','A','R')) demux_info_add(demuxer,"Date",sdata); + else + if(sid==mmioFOURCC('T','R','A','C')) demux_info_add(demuxer,"Track",sdata); + else + if(sid==mmioFOURCC('E','N','C','D')) demux_info_add(demuxer,"Encoder",sdata); + else + mp_msg(MSGT_DEMUX, MSGL_V, "Unhandled subchunk '%c%c%c%c'='%s'\n",((char *)&sid)[0],((char *)&sid)[1],((char *)&sid)[2],((char *)&sid)[3],sdata); + /* other stuff is unrecognized due untranslatable japan's idiomatics */ + } + } + else + if(*((uint32_t *)&chunk_id[0])==mmioFOURCC('D','A','T','A')) + { + demuxer->movi_start=stream_tell(s); + demuxer->movi_end=demuxer->movi_start+chunk_size-8; + mp_msg(MSGT_DEMUX, MSGL_V, "Found data at %llX size %llu\n",demuxer->movi_start,demuxer->movi_end); + /* Done! play it */ + break; + } + else + { + mp_msg(MSGT_DEMUX, MSGL_V, "Unhandled chunk '%c%c%c%c' %u bytes\n",((char *)&chunk_id)[0],((char *)&chunk_id)[1],((char *)&chunk_id)[2],((char *)&chunk_id)[3],chunk_size); + stream_skip(s,chunk_size-8); /*unknown chunk type */ + } + } + + demuxer->audio->sh = sh_audio; + sh_audio->ds = demuxer->audio; + stream_seek(s,demuxer->movi_start); + demuxer->seekable=0; + return demuxer; +} + +int demux_vqf_fill_buffer(demuxer_t* demuxer, demux_stream_t *ds) { + sh_audio_t* sh_audio = demuxer->audio->sh; + int l = sh_audio->wf->nAvgBytesPerSec; + off_t spos = stream_tell(demuxer->stream); + demux_packet_t* dp; + + if(stream_eof(demuxer->stream)) + return 0; + + dp = new_demux_packet(l); + ds->pts = spos / (float)(sh_audio->wf->nAvgBytesPerSec); + ds->pos = spos; + + l=stream_read(demuxer->stream,dp->buffer,l); + resize_demux_packet(dp,l); + ds_add_packet(ds,dp); + + return 1; +} + +void demux_seek_vqf(demuxer_t *demuxer,float rel_seek_secs,int flags){ +#if 0 + stream_t* s = demuxer->stream; + sh_audio_t* sh_audio = demuxer->audio->sh; + off_t base,pos; + + base = (flags & 1) ? demuxer->movi_start : stream_tell(s); + if(flags & 2) + pos = base + ((demuxer->movi_end - demuxer->movi_start)*rel_seek_secs); + else + pos = base + (rel_seek_secs*sh_audio->i_bps); + + pos -= (pos % (sh_audio->channels * sh_audio->samplesize) ); + stream_seek(s,pos); + resync_audio_stream(sh_audio); +#endif +} + +void demux_close_vqf(demuxer_t* demuxer) {} diff -r de13fd557440 -r fa80ed52127b libmpdemux/demuxer.c --- a/libmpdemux/demuxer.c Wed Dec 29 19:50:44 2004 +0000 +++ b/libmpdemux/demuxer.c Wed Dec 29 19:51:56 2004 +0000 @@ -156,6 +156,7 @@ extern void demux_close_ra(demuxer_t* demuxer); extern void demux_close_ty(demuxer_t* demuxer); extern void demux_close_lavf(demuxer_t* demuxer); +extern void demux_close_vqf(demuxer_t* demuxer); #ifdef USE_TV @@ -241,6 +242,8 @@ demux_close_mpg(demuxer); break; case DEMUXER_TYPE_REALAUDIO: demux_close_ra(demuxer); break; + case DEMUXER_TYPE_VQF: + demux_close_vqf(demuxer); break; #ifdef USE_LIBAVFORMAT case DEMUXER_TYPE_LAVF: demux_close_lavf(demuxer); break; @@ -326,6 +329,7 @@ int demux_gif_fill_buffer(demuxer_t *demux); int demux_ts_fill_buffer(demuxer_t *demux); int demux_ra_fill_buffer(demuxer_t *demux); +int demux_vqf_fill_buffer(demuxer_t *demux); extern int demux_demuxers_fill_buffer(demuxer_t *demux,demux_stream_t *ds); extern int demux_ogg_fill_buffer(demuxer_t *d); @@ -390,6 +394,7 @@ case DEMUXER_TYPE_MPEG_TS: return demux_ts_fill_buffer(demux); case DEMUXER_TYPE_REALAUDIO: return demux_ra_fill_buffer(demux); + case DEMUXER_TYPE_VQF: return demux_vqf_fill_buffer(demux); #ifdef USE_LIBAVFORMAT case DEMUXER_TYPE_LAVF: return demux_lavf_fill_buffer(demux); #endif @@ -634,6 +639,8 @@ extern int demux_open_mkv(demuxer_t *demuxer); extern int ra_check_file(demuxer_t *demuxer); extern int demux_open_ra(demuxer_t* demuxer); +extern int demux_probe_vqf(demuxer_t *demuxer); +extern int demux_open_vqf(demuxer_t* demuxer); #ifdef HAVE_MATROSKA extern int demux_mkv_open(demuxer_t *demuxer); #endif @@ -809,6 +816,18 @@ } } +//=============== Try to open as VQF file: ================= +if(file_format==DEMUXER_TYPE_UNKNOWN || file_format==DEMUXER_TYPE_VQF){ + demuxer=new_demuxer(stream,DEMUXER_TYPE_VQF,audio_id,video_id,dvdsub_id); + if(demux_probe_vqf(demuxer)){ + mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_Detected_XXX_FileFormat,"VQF"); + file_format=DEMUXER_TYPE_VQF; + } else { + free_demuxer(demuxer); + demuxer = NULL; + } +} + //=============== Try based on filename EXTENSION: ================= // Ok. We're over the stable detectable fileformats, the next ones are a bit // fuzzy. So by default (extension_parsing==1) try extension-based detection @@ -1355,6 +1374,10 @@ if (!demux_open_ra(demuxer)) return NULL; break; } + case DEMUXER_TYPE_VQF: { + if (!demux_open_vqf(demuxer)) return NULL; + break; + } #ifdef USE_LIBAVFORMAT case DEMUXER_TYPE_LAVF: { if (!demux_open_lavf(demuxer)) return NULL; @@ -1474,6 +1497,7 @@ extern void demux_rawvideo_seek(demuxer_t *demuxer,float rel_seek_secs,int flags); extern void demux_xmms_seek(demuxer_t *demuxer,float rel_seek_secs,int flags); extern void demux_mkv_seek(demuxer_t *demuxer,float rel_seek_secs,int flags); +extern void demux_seek_vqf(demuxer_t *demuxer,float rel_seek_secs,int flags); int demux_seek(demuxer_t *demuxer,float rel_seek_secs,int flags){ demux_stream_t *d_audio=demuxer->audio; @@ -1576,6 +1600,8 @@ case DEMUXER_TYPE_LAVF: demux_seek_lavf(demuxer,rel_seek_secs,flags); break; #endif + case DEMUXER_TYPE_VQF: + demux_seek_vqf(demuxer,rel_seek_secs,flags); break; } // switch(demuxer->file_format) diff -r de13fd557440 -r fa80ed52127b libmpdemux/demuxer.h --- a/libmpdemux/demuxer.h Wed Dec 29 19:50:44 2004 +0000 +++ b/libmpdemux/demuxer.h Wed Dec 29 19:51:56 2004 +0000 @@ -44,11 +44,12 @@ #define DEMUXER_TYPE_LMLM4 34 #define DEMUXER_TYPE_LAVF 35 #define DEMUXER_TYPE_NSV 36 +#define DEMUXER_TYPE_VQF 37 // This should always match the higest demuxer type number. // Unless you want to disallow users to force the demuxer to some types #define DEMUXER_TYPE_MIN 0 -#define DEMUXER_TYPE_MAX 36 +#define DEMUXER_TYPE_MAX 37 #define DEMUXER_TYPE_DEMUXERS (1<<16) // A virtual demuxer type for the network code