Changeset 3805

Show
Ignore:
Timestamp:
09/06/06 02:34:26 (8 years ago)
Author:
rhys
Message:

Added DV payload types to rtp code.
Implemented H261AS encoder, VIC can send h261as to VP.

Location:
vic/trunk
Files:
1 added
4 modified

Legend:

Unmodified
Added
Removed
  • vic/trunk/codec/encoder-h261as.cpp

    r3795 r3805  
    1 /* 
    2  * Copyright (c) 1994-1995 The Regents of the University of California. 
    3  * All rights reserved. 
    4  * 
    5  * Redistribution and use in source and binary forms, with or without 
    6  * modification, are permitted provided that the following conditions 
    7  * are met: 
    8  * 1. Redistributions of source code must retain the above copyright 
    9  *    notice, this list of conditions and the following disclaimer. 
    10  * 2. Redistributions in binary form must reproduce the above copyright 
    11  *    notice, this list of conditions and the following disclaimer in the 
    12  *    documentation and/or other materials provided with the distribution. 
    13  * 3. All advertising materials mentioning features or use of this software 
    14  *    must display the following acknowledgement: 
    15  *      This product includes software developed by the University of 
    16  *      California, Berkeley and the Network Research Group at 
    17  *      Lawrence Berkeley Laboratory. 
    18  * 4. Neither the name of the University nor of the Laboratory may be used 
    19  *    to endorse or promote products derived from this software without 
    20  *    specific prior written permission. 
    21  * 
    22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 
    23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
    24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
    25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 
    26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
    27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
    28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
    29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
    30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
    31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
    32  * SUCH DAMAGE. 
    33  */ 
    34 static const char rcsid[] = 
    35     "@(#) $Header$ (LBL)"; 
    361 
    372#include <stdio.h> 
     
    5217 
    5318#define HDRSIZE (sizeof(rtphdr) + 4) 
     19#define DEFAULT_THRESHOLD 48 
    5420#define CIF_WIDTH       352 
    5521#define CIF_HEIGHT      288 
     
    11783class H261ASEncoder : public TransmitterModule { 
    11884    public: 
     85        H261ASEncoder(); 
     86        ~H261ASEncoder(); 
    11987        void setq(int q); 
     88        int consume(const VideoFrame*); 
    12089    protected: 
    121         H261ASEncoder(int ft); 
    122         ~H261ASEncoder(); 
    12390        int encode(const VideoFrame*, const u_int8_t *crvec); 
    12491        int command(int argc, const char*const* argv); 
     
    12794        char* make_level_map(int q, u_int fthresh); 
    12895        void setquantizers(int lq, int mq, int hq); 
    129  
    130         virtual void size(int w, int h) = 0; 
    131         virtual void encode_mb(u_int mba, const u_char* frm, 
    132                        u_int loff, u_int coff, int how) = 0; 
    133  
    134         /* bit buffer */ 
    135         BB_INT bb_; 
    136         u_int nbb_; 
    137  
    138         u_char* bs_; 
    139         u_char* bc_; 
    140         int sbit_; 
    141  
    142         u_char lq_;             /* low quality quantizer */ 
    143         u_char mq_;             /* medium quality quantizer */ 
    144         u_char hq_;             /* high quality quantizer */ 
    145         u_char mquant_;         /* the last quantizer we sent to other side */ 
    146         int quant_required_;    /* 1 if not quant'd in dct */ 
    147         u_int ngob_; 
    148         u_int mba_; 
    149  
    150         u_int cif_;             /* 1 for CIF, 0 for QCIF */ 
    151         u_int bstride_; 
    152         u_int lstride_; 
    153         u_int cstride_; 
    154  
    155         u_int loffsize_;        /* amount of 1 luma block */ 
    156         u_int coffsize_;        /* amount of 1 chroma block */ 
    157         u_int bloffsize_;       /* amount of 1 block advance */ 
    158  
    159         const char* llm_[32];   /* luma dct val -> level maps */ 
    160         const char* clm_[32];   /* chroma dct val -> level maps */ 
    161  
    162         float lqt_[64];         /* low quality quantizer */ 
    163         float mqt_[64];         /* medium quality quantizer */ 
    164         float hqt_[64];         /* high quality quantizer */ 
    165  
    166         u_int coff_[12];        /* where to find U given gob# */ 
    167         u_int loff_[12];        /* where to find Y given gob# */ 
    168         u_int blkno_[12];       /* for CR */ 
    169 }; 
    170  
    171 class H261ASDCTEncoder : public H261ASEncoder { 
    172     public: 
    173         H261ASDCTEncoder(); 
    174         int consume(const VideoFrame*); 
    17596        void size(int w, int h); 
    176     protected: 
    17797        void encode_mb(u_int mba, const u_char* frm, 
    17898                       u_int loff, u_int coff, int how); 
    179 }; 
    180  
    181 class H261ASPixelEncoder : public H261ASEncoder { 
    182     public: 
    183         H261ASPixelEncoder(); 
    184         int consume(const VideoFrame*); 
    185         void size(int w, int h); 
    186     protected: 
    187         void encode_mb(u_int mba, const u_char* frm, 
    188                        u_int loff, u_int coff, int how); 
     99 
     100        u_int width; 
     101        u_int height; 
     102        u_char *frame_buffer; 
     103        u_int frame_buffer_size; 
     104 
     105        u_char *crref; 
     106        u_char *crvec; 
     107 
     108        int nblk; 
     109        int blkw; 
     110        int blkh; 
     111        int rover; 
     112        int threshold; 
     113        int scan; 
     114 
     115        u_char *bs; 
     116        u_char *bc; 
     117        int bb; 
     118        int nbb; 
     119        int sbit; 
     120        int tx; 
     121        int lq; 
     122        int mq; 
     123        int hq; 
     124        u_int ngob; 
     125        u_int nblocks; 
     126        int mquant; 
     127        int mba; 
     128 
     129        int *loff_table; 
     130        int *coff_table; 
     131        int *blkno_table; 
     132 
     133        float lqt[64]; 
     134        float mqt[64]; 
     135        float hqt[64]; 
     136 
     137        const char *llm[32]; 
     138        const char *clm[32]; 
    189139}; 
    190140 
     
    193143        H261ASEncoderMatcher() : Matcher("module") {} 
    194144        TclObject* match(const char* fmt) { 
    195                 if (strcasecmp(fmt, "h261as/pixel") == 0) 
    196                         return (new H261ASPixelEncoder); 
    197                 if (strcasecmp(fmt, "h261as/dct") == 0) 
    198                         return (new H261ASDCTEncoder); 
    199                 /* XXX for now, this is compatible with ui-ctrlmenu.tcl */ 
    200                 if (strcasecmp(fmt, "h261as") == 0) 
    201                         return (new H261ASPixelEncoder); 
     145                if (strcasecmp(fmt, "h261as") == 0 || 
     146                    strcasecmp(fmt, "h.261as") == 0) 
     147                        return (new H261ASEncoder); 
    202148                return (0); 
    203149        } 
     
    205151 
    206152 
    207 H261ASEncoder::H261ASEncoder(int ft) : TransmitterModule(ft), 
    208         bs_(0), bc_(0), ngob_(12) 
     153H261ASEncoder::H261ASEncoder() : TransmitterModule(FT_YUV_411), 
     154                                 frame_buffer(0), 
     155                                 frame_buffer_size(0), 
     156                                 crref(0), 
     157                                 crvec(0), 
     158                                 nblk(0), 
     159                                 blkw(0), 
     160                                 blkh(0), 
     161                                 rover(0), 
     162                                 threshold(DEFAULT_THRESHOLD), 
     163                                 scan(0), 
     164                                 loff_table(0), 
     165                                 coff_table(0) 
    209166{ 
    210167        for (int q = 0; q < 32; ++q) { 
    211                 llm_[q] = 0; 
    212                 clm_[q] = 0; 
    213         } 
     168                llm[q] = 0; 
     169                clm[q] = 0; 
     170        } 
     171        setq(10); 
    214172} 
    215173 
     
    217175{ 
    218176        for (int q = 0; q < 32; ++q) { 
    219                 if (llm_[q] != 0) 
    220                         delete llm_[q]; //SV-XXX: Debian 
    221                 if (clm_[q] != 0) 
    222                         delete clm_[q]; //SV-XXX: Debian 
    223         } 
    224 } 
    225  
    226 H261ASPixelEncoder::H261ASPixelEncoder() : H261ASEncoder(FT_YUV_CIF) 
    227 { 
    228         quant_required_ = 0; 
    229         setq(10); 
    230 } 
    231  
    232 H261ASDCTEncoder::H261ASDCTEncoder() : H261ASEncoder(FT_DCT) 
    233 { 
    234         quant_required_ = 1; 
    235         setq(10); 
     177                if (llm[q] != 0) 
     178                        delete llm[q]; //SV-XXX: Debian 
     179                if (clm[q] != 0) 
     180                        delete clm[q]; //SV-XXX: Debian 
     181        } 
    236182} 
    237183 
     
    241187 */ 
    242188void 
    243 H261ASEncoder::setquantizers(int lq, int mq, int hq) 
     189H261ASEncoder::setquantizers(int _lq, int _mq, int _hq) 
    244190{ 
    245191        int qt[64]; 
     192        lq = _lq; 
    246193        if (lq > 31) 
    247194                lq = 31; 
    248195        if (lq <= 0) 
    249196                lq = 1; 
    250         lq_ = lq; 
    251  
     197 
     198        mq = _mq; 
    252199        if (mq > 31) 
    253200                mq = 31; 
    254201        if (mq <= 0) 
    255202                mq = 1; 
    256         mq_ = mq; 
    257  
     203 
     204        hq = _hq; 
    258205        if (hq > 31) 
    259206                hq = 31; 
    260207        if (hq <= 0) 
    261208                hq = 1; 
    262         hq_ = hq; 
    263  
    264         /* 
    265          * quant_required_ indicates quantization is not folded 
    266          * into fdct [because fdct is not performed] 
    267          */ 
    268         if (quant_required_ == 0) { 
    269                 /* 
    270                  * Set the DC quantizer to 1, since we want to do this 
    271                  * coefficient differently (i.e., the DC is rounded while 
    272                  * the AC terms are truncated). 
    273                  */ 
    274                 qt[0] = 1; 
    275                 int i; 
    276                 for (i = 1; i < 64; ++i) 
    277                         qt[i] = lq_ << 1; 
    278                 fdct_fold_q(qt, lqt_); 
    279  
    280                 qt[0] = 1; 
    281                 for (i = 1; i < 64; ++i) 
    282                         qt[i] = mq_ << 1; 
    283                 fdct_fold_q(qt, mqt_); 
    284  
    285                 qt[0] = 1; 
    286                 for (i = 1; i < 64; ++i) 
    287                         qt[i] = hq_ << 1; 
    288                 fdct_fold_q(qt, hqt_); 
    289         } 
     209 
     210        /* 
     211         * Set the DC quantizer to 1, since we want to do this 
     212         * coefficient differently (i.e., the DC is rounded while 
     213         * the AC terms are truncated). 
     214         */ 
     215        qt[0] = 1; 
     216        int i; 
     217        for (i = 1; i < 64; ++i) 
     218          qt[i] = lq << 1; 
     219        fdct_fold_q(qt, lqt); 
     220         
     221        qt[0] = 1; 
     222        for (i = 1; i < 64; ++i) 
     223          qt[i] = mq << 1; 
     224        fdct_fold_q(qt, mqt); 
     225         
     226        qt[0] = 1; 
     227        for (i = 1; i < 64; ++i) 
     228          qt[i] = hq << 1; 
     229        fdct_fold_q(qt, hqt); 
    290230} 
    291231 
     
    297237 
    298238void 
    299 H261ASPixelEncoder::size(int w, int h) 
    300 { 
    301         Module::size(w, h); 
    302         if (w == CIF_WIDTH && h == CIF_HEIGHT) { 
    303                 /* CIF */ 
    304                 cif_ = 1; 
    305                 ngob_ = 12; 
    306                 bstride_ = 11; 
    307                 lstride_ = 16 * CIF_WIDTH - CIF_WIDTH / 2; 
    308                 cstride_ = 8 * 176 - 176 / 2; 
    309                 loffsize_ = 16; 
    310                 coffsize_ = 8; 
    311                 bloffsize_ = 1; 
    312         } else if (w == QCIF_WIDTH && h == QCIF_HEIGHT) { 
    313                 /* QCIF */ 
    314                 cif_ = 0; 
    315                 ngob_ = 6; /* not really number of GOBs, just loop limit */ 
    316                 bstride_ = 0; 
    317                 lstride_ = 16 * QCIF_WIDTH - QCIF_WIDTH; 
    318                 cstride_ = 8 * 88 - 88; 
    319                 loffsize_ = 16; 
    320                 coffsize_ = 8; 
    321                 bloffsize_ = 1; 
    322         } else { 
    323                 /*XXX*/ 
    324                 fprintf(stderr, "H261ASPixelEncoder: H.261 bad geometry: %dx%d\n", 
    325                         w, h); 
    326                 exit(1); 
    327         } 
    328         u_int loff = 0; 
    329         u_int coff = 0; 
    330         u_int blkno = 0; 
    331         for (u_int gob = 0; gob < ngob_; gob += 2) { 
    332                 loff_[gob] = loff; 
    333                 coff_[gob] = coff; 
    334                 blkno_[gob] = blkno; 
    335                 /* width of a GOB (these aren't ref'd in QCIF case) */ 
    336                 loff_[gob + 1] = loff + 11 * 16; 
    337                 coff_[gob + 1] = coff + 11 * 8; 
    338                 blkno_[gob + 1] = blkno + 11; 
    339  
    340                 /* advance to next GOB row */ 
    341                 loff += (16 * 16 * MBPERGOB) << cif_; 
    342                 coff += (8 * 8 * MBPERGOB) << cif_; 
    343                 blkno += MBPERGOB << cif_; 
    344         } 
    345 } 
    346  
    347 void 
    348 H261ASDCTEncoder::size(int w, int h) 
    349 { 
    350  
    351         Module::size(w, h); 
    352         if (w == CIF_WIDTH && h == CIF_HEIGHT) { 
    353                 /* CIF */ 
    354                 cif_ = 1; 
    355                 ngob_ = 12; 
    356                 bstride_ = 11; 
    357                 lstride_ = - (11 * (64*BMB)) + 2 * 11 * 64 * BMB; 
    358                 cstride_ = - (11 * (64*BMB)) + 2 * 11 * 64 * BMB; 
    359                 loffsize_ = 64 * BMB; 
    360                 coffsize_ = 64 * BMB; 
    361                 bloffsize_ = 1; 
    362         } else if (w == QCIF_WIDTH && h == QCIF_HEIGHT) { 
    363                 /* QCIF */ 
    364                 cif_ = 0; 
    365                 ngob_ = 6; /* not really number of GOBs, just loop limit */ 
    366                 bstride_ = 0; 
    367                 lstride_ = 0; 
    368                 cstride_ = 0; 
    369                 loffsize_ = 64 * BMB; 
    370                 coffsize_ = 64 * BMB; 
    371                 bloffsize_ = 1; 
    372         } else { 
    373                 /*XXX*/ 
    374                 fprintf(stderr, "H261ASDCTEncoder: H.261 bad geometry: %dx%d\n", 
    375                         w, h); 
    376                 exit(1); 
    377         } 
    378  
    379         u_int gob; 
    380         for (gob = 0; gob < ngob_; gob += 2) { 
    381  
    382                 if (gob != 0) { 
    383                         loff_[gob] = loff_[gob-2] + 
    384                                 (MBPERGOB << cif_) * BMB * 64; 
    385                         coff_[gob] = coff_[gob-2] + 
    386                                 (MBPERGOB << cif_) * BMB * 64; 
    387                         blkno_[gob] = blkno_[gob-2] + 
    388                                 (MBPERGOB << cif_); 
    389                 } else { 
    390                         loff_[0] = 0; 
    391                         coff_[0] = loff_[0] + 4 * 64;   // 4 Y's 
    392                         blkno_[0] = 0; 
    393                 } 
    394  
    395                 loff_[gob + 1] = loff_[gob] + 11 * BMB * 64; 
    396                 coff_[gob + 1] = coff_[gob] + 11 * BMB * 64; 
    397                 blkno_[gob + 1] = blkno_[gob] + 11; 
    398         } 
    399 } 
    400  
     239H261ASEncoder::size(int w, int h) 
     240{ 
     241        Module::size(w, h); 
     242   
     243        if (w % 16 != 0) { 
     244                w += 16 - (w % 16); 
     245        } 
     246        if (h % 16 != 0) { 
     247                h += 16 - (h % 16); 
     248        } 
     249 
     250        width = w; 
     251        height = h; 
     252 
     253        if (frame_buffer) { 
     254                delete [] frame_buffer; 
     255        } 
     256        frame_buffer_size = (width * height * 3)/2; 
     257        frame_buffer = new u_char[frame_buffer_size]; 
     258        memset(frame_buffer, 127, frame_buffer_size); 
     259 
     260        if (crref) { 
     261                delete [] crref; 
     262        } 
     263        crref = new u_char[width * height]; 
     264         
     265        if (crvec) { 
     266                delete [] crvec; 
     267        } 
     268        nblk = (width * height) >> 8; 
     269        crvec = new u_char[nblk]; 
     270 
     271        blkw = width/16; 
     272        blkh = height/16; 
     273 
     274        nblocks = blkw * blkh; 
     275        ngob = nblocks/33; 
     276        if (ngob * 33 < nblocks) { 
     277                ngob ++; 
     278        } 
     279 
     280        if (loff_table) { 
     281                delete [] loff_table; 
     282        } 
     283        loff_table = new int[nblocks]; 
     284        if (coff_table) { 
     285                delete [] coff_table; 
     286        } 
     287        coff_table = new int[nblocks]; 
     288 
     289        int i = 0; 
     290        int loff = 0; 
     291        int coff = 0; 
     292        int l_rs = 15 * width; 
     293        int c_rs = 7 * width/2; 
     294        for (int y = 0; y < blkh; y ++) { 
     295                for (int x = 0; x < blkw; x ++, i ++) { 
     296                        loff_table[i] = loff; 
     297                        coff_table[i] = coff; 
     298 
     299                        loff += 16; 
     300                        coff += 8; 
     301                } 
     302 
     303                loff += l_rs; 
     304                coff += c_rs; 
     305        } 
     306} 
    401307 
    402308int 
     
    428334        lm[0] = 0; 
    429335        flm[0] = 0; 
    430         q = quant_required_? q << 1 : 0; 
     336        q = 0; 
    431337        for (i = 1; i < 0x800; ++i) { 
    432338                int l = i; 
     
    451357H261ASEncoder::encode_blk(const short* blk, const char* lm) 
    452358{ 
    453         BB_INT bb = bb_; 
    454         u_int nbb = nbb_; 
    455         u_char* bc = bc_; 
     359        BB_INT t_bb = bb; 
     360        u_int t_nbb = nbb; 
     361        u_char* t_bc = bc; 
    456362 
    457363        /* 
     
    469375                dc = 255; 
    470376        /* Code DC */ 
    471         PUT_BITS(dc, 8, nbb, bb, bc); 
     377        PUT_BITS(dc, 8, t_nbb, t_bb, t_bc); 
    472378        int run = 0; 
    473379        const u_char* colzag = &COLZAG[0]; 
     
    488394                                nb = 20; 
    489395                        } 
    490                         PUT_BITS(val, nb, nbb, bb, bc); 
     396                        PUT_BITS(val, nb, t_nbb, t_bb, t_bc); 
    491397                        run = 0; 
    492398                } else 
     
    494400        } 
    495401        /* EOB */ 
    496         PUT_BITS(2, 2, nbb, bb, bc); 
    497  
    498         bb_ = bb; 
    499         nbb_ = nbb; 
    500         bc_ = bc; 
     402        PUT_BITS(2, 2, t_nbb, t_bb, t_bc); 
     403 
     404        bb = t_bb; 
     405        nbb = t_nbb; 
     406        bc = t_bc; 
    501407} 
    502408 
    503409/* 
    504  * H261ASPixelEncoder::encode_mb 
     410 * H261ASEncoder::encode_mb 
    505411 *      encode a macroblock given a set of input YUV pixels 
    506412 */ 
    507413void 
    508 H261ASPixelEncoder::encode_mb(u_int mba, const u_char* frm, 
     414H261ASEncoder::encode_mb(u_int mbal, const u_char* frm, 
    509415                            u_int loff, u_int coff, int how) 
    510416{ 
     
    512418        float* qt; 
    513419        if (how == CR_MOTION) { 
    514                 q = lq_; 
    515                 qt = lqt_; 
     420                q = lq; 
     421                qt = lqt; 
    516422        } else if (how == CR_BG) { 
    517                 q = hq_; 
    518                 qt = hqt_;  
     423                q = hq; 
     424                qt = hqt;  
    519425        } else { 
    520426                /* must be at age threshold */ 
    521                 q = mq_; 
    522                 qt = mqt_;  
     427                q = mq; 
     428                qt = mqt;  
    523429        } 
    524430 
     
    530436        /*XXX this can be u_char instead of short but need smarts in fdct */ 
    531437        short blk[64 * 6]; 
    532         register int stride = width_; 
     438        register int stride = width; 
    533439        /* luminance */ 
    534440        const u_char* p = &frm[loff]; 
     
    538444        fdct(p + (8 * stride + 8), stride, blk + 192, qt); 
    539445        /* chominance */ 
    540         int fs = framesize_; 
     446        int fs = stride * height; 
    541447        p = &frm[fs + coff]; 
    542448        stride >>= 1; 
     
    581487        } 
    582488 
    583         u_int m = mba - mba_; 
    584         mba_ = mba; 
     489        u_int m = mbal - mba; 
     490        mba = mbal; 
    585491        huffent* he = &hte_mba[m - 1]; 
    586492        /* MBA */ 
    587         PUT_BITS(he->val, he->nb, nbb_, bb_, bc_); 
    588         if (q != mquant_) { 
     493        PUT_BITS(he->val, he->nb, nbb, bb, bc); 
     494        if (q != mquant) { 
    589495                /* MTYPE = INTRA + TC + MQUANT */ 
    590                 PUT_BITS(1, 7, nbb_, bb_, bc_); 
    591                 PUT_BITS(q, 5, nbb_, bb_, bc_); 
    592                 mquant_ = q; 
     496                PUT_BITS(1, 7, nbb, bb, bc); 
     497                PUT_BITS(q, 5, nbb, bb, bc); 
     498                mquant = q; 
    593499        } else { 
    594500                /* MTYPE = INTRA + TC (no quantizer) */ 
    595                 PUT_BITS(1, 4, nbb_, bb_, bc_); 
     501                PUT_BITS(1, 4, nbb, bb, bc); 
    596502        } 
    597503 
    598504        /* luminance */ 
    599         const char* lm = llm_[q]; 
     505        const char* lm = llm[q]; 
    600506        if (lm == 0) { 
    601507                lm = make_level_map(q, 1); 
    602                 llm_[q] = lm; 
    603                 clm_[q] = make_level_map(q, 2); 
     508                llm[q] = lm; 
     509                clm[q] = make_level_map(q, 2); 
    604510        } 
    605511        encode_blk(blk + 0, lm); 
     
    608514        encode_blk(blk + 192, lm); 
    609515        /* chominance */ 
    610         lm = clm_[q]; 
     516        lm = clm[q]; 
    611517        encode_blk(blk + 256, lm); 
    612518        encode_blk(blk + 320, lm); 
    613519} 
    614520 
    615  
    616 /* 
    617  * H261ASDCTEncoder::encode_mb 
    618  *      encode a macroblock given a set of input DCT coefs 
    619  *      each coef is stored as a short 
    620  */ 
    621 void 
    622 H261ASDCTEncoder::encode_mb(u_int mba, const u_char* frm, 
    623                           u_int loff, u_int coff, int how) 
    624 { 
    625         short *lblk = (short *)frm + loff; 
    626         short *ublk = (short *)frm + coff; 
    627         short *vblk = (short *)frm + coff + 64; 
    628  
    629         register u_int q; 
    630         if (how == CR_MOTION) 
    631                 q = lq_; 
    632         else if (how == CR_BG) 
    633                 q = hq_; 
    634         else 
    635                 /* must be at age threshold */ 
    636                 q = mq_; 
    637  
    638         /* 
    639          * if the default quantizer is too small to handle the coef. 
    640          * dynamic range, spin through the blocks and see if any 
    641          * coef. would significantly overflow. 
    642          */ 
    643         if (q < 8) { 
    644                 register int cmin = 0, cmax = 0; 
    645                 register short* bp = lblk; 
    646                 register int i, j; 
    647  
    648                 // Y U and V blocks 
    649                 for (i = 6; --i >= 0; ) { 
    650                         ++bp;   // ignore dc coef 
    651                         for (j = 63; --j >= 0; ) { 
    652                                 register int v = *bp++; 
    653                                 if (v < cmin) 
    654                                         cmin = v; 
    655                                 else if (v > cmax) 
    656                                         cmax = v; 
    657                         } 
    658                 } 
    659  
    660                 if (cmax < -cmin) 
    661                         cmax = -cmin; 
    662                 cmax /= (q << 1); 
    663                 if (cmax >= 128) { 
    664                         /* need to re-quantize */ 
    665                         register int s; 
    666  
    667                         for (s = 1; cmax >= (128 << s); ++s) { 
    668                         } 
    669                         q <<= s; 
    670  
    671                 } 
    672         } 
    673  
    674         u_int m = mba - mba_; 
    675         mba_ = mba; 
    676         huffent* he = &hte_mba[m - 1]; 
    677         /* MBA */ 
    678         PUT_BITS(he->val, he->nb, nbb_, bb_, bc_); 
    679         if (q != mquant_) { 
    680                 /* MTYPE = INTRA + TC + MQUANT */ 
    681                 PUT_BITS(1, 7, nbb_, bb_, bc_); 
    682                 PUT_BITS(q, 5, nbb_, bb_, bc_); 
    683                 mquant_ = q; 
    684         } else { 
    685                 /* MTYPE = INTRA + TC (no quantizer) */ 
    686                 PUT_BITS(1, 4, nbb_, bb_, bc_); 
    687         } 
    688  
    689         /* luminance */ 
    690         const char* lm = llm_[q]; 
    691         if (lm == 0) { 
    692                 /* 
    693                  * the filter thresh is 0 since we assume the jpeg percept. 
    694                  * quantizer already did the filtering. 
    695                  */ 
    696                 lm = make_level_map(q, 0); 
    697                 llm_[q] = lm; 
    698                 clm_[q] = make_level_map(q, 0); 
    699         } 
    700         encode_blk(lblk + 0, lm); 
    701         encode_blk(lblk + 64, lm); 
    702         encode_blk(lblk + 128, lm); 
    703         encode_blk(lblk + 192, lm); 
    704         /* chominance */ 
    705         lm = clm_[q]; 
    706         encode_blk(ublk, lm); 
    707         encode_blk(vblk, lm); 
    708 } 
    709  
    710521int 
    711522H261ASEncoder::flush(pktbuf* pb, int nbit, pktbuf* npb) 
    712523{ 
    713524        /* flush bit buffer */ 
    714         STORE_BITS(bb_, bc_); 
     525        STORE_BITS(bb, bc); 
    715526 
    716527        int cc = (nbit + 7) >> 3; 
     
    726537                rh->rh_flags |= htons(RTP_M); 
    727538 
    728         int h = *(u_int*)(rh + 1) | ebit << 26 | sbit_ << 29; 
     539        int h = *(u_int*)(rh + 1) | ebit << 26; 
    729540        *(u_int*)(rh + 1) = htonl(h); 
    730541 
    731542        if (npb != 0) { 
    732                 u_char* nbs = &npb->data[HDRSIZE]; 
    733                 u_int bc = (bc_ - bs_) << 3; 
    734                 int tbit = bc + nbb_; 
    735                 int extra = ((tbit + 7) >> 3) - (nbit >> 3); 
    736                 if (extra > 0) 
    737                         memcpy(nbs, bs_ + (nbit >> 3), extra); 
    738                 bs_ = nbs; 
    739                 sbit_ = nbit & 7; 
    740                 tbit -= nbit &~ 7; 
    741                 bc = tbit &~ (NBIT - 1); 
    742                 nbb_ = tbit - bc; 
    743                 bc_ = bs_ + (bc >> 3); 
    744                 /* 
    745                  * Prime the bit buffer.  Be careful to set bits that 
    746                  * are not yet in use to 0, since output bits are later 
    747                  * or'd into the buffer. 
    748                  */ 
    749                 if (nbb_ > 0) { 
    750                         u_int n = NBIT - nbb_; 
    751                         bb_ = (LOAD_BITS(bc_) >> n) << n; 
    752                 } else 
    753                         bb_ = 0; 
     543                bs = &npb->data[HDRSIZE]; 
     544                bc = bs; 
     545                bb = 0; 
     546                nbb = 0; 
     547                sbit = 0; 
    754548        } 
    755549        tx_->send(pb); 
     
    758552} 
    759553 
    760 int H261ASDCTEncoder::consume(const VideoFrame *vf) 
     554int H261ASEncoder::consume(const VideoFrame *vf) 
    761555{ 
    762556        if (!samesize(vf)) 
    763557                size(vf->width_, vf->height_); 
    764558 
    765         DCTFrame* df = (DCTFrame *)vf; 
    766  
    767         return(encode(df, df->crvec_)); 
    768 } 
    769  
    770 int H261ASPixelEncoder::consume(const VideoFrame *vf) 
    771 { 
    772         if (!samesize(vf)) 
    773                 size(vf->width_, vf->height_); 
    774  
    775559        YuvFrame* p = (YuvFrame*)vf; 
    776560        return(encode(p, p->crvec_)); 
     
    783567        tx_->flush(); 
    784568 
    785         pktbuf* pb = pool_->alloc(vf->ts_, RTP_PT_H261); 
    786         bs_ = &pb->data[HDRSIZE]; 
    787         bc_ = bs_; 
     569        pktbuf* pb = pool_->alloc(vf->ts_, RTP_PT_H261AS); 
     570        bs = &pb->data[HDRSIZE]; 
     571        bc = bs; 
    788572        u_int ec = (tx_->mtu() - HDRSIZE) << 3; 
    789         bb_ = 0; 
    790         nbb_ = 0; 
    791         sbit_ = 0; 
     573        bb = 0; 
     574        nbb = 0; 
     575 
    792576        /* RTP/H.261 header */ 
    793577        rtphdr* rh = (rtphdr*)pb->data; 
    794         *(u_int*)(rh + 1) = 1 << 25 | lq_ << 10; 
    795  
    796         /* PSC */ 
    797         PUT_BITS(0x0001, 16, nbb_, bb_, bc_); 
    798         /* GOB 0 -> picture header */ 
    799         PUT_BITS(0, 4, nbb_, bb_, bc_); 
    800         /* TR (XXX should do this right) */ 
    801         PUT_BITS(0, 5, nbb_, bb_, bc_); 
    802         /* PTYPE = CIF */ 
    803         int pt = cif_ ? 4 : 0; 
    804         PUT_BITS(pt, 6, nbb_, bb_, bc_); 
    805         /* PEI */ 
    806         PUT_BITS(0, 1, nbb_, bb_, bc_); 
    807  
    808         int step = cif_ ? 1 : 2; 
     578        *(u_int*)(rh + 1) = lq << 24 | ((width >> 4) - 1) << 12 | ((height >> 4) - 1); 
     579 
    809580        int cc = 0; 
    810  
    811581        u_int8_t* frm = vf->bp_; 
    812         for (u_int gob = 0; gob < ngob_; gob += step) { 
    813                 u_int loff = loff_[gob]; 
    814                 u_int coff = coff_[gob]; 
    815                 u_int blkno = blkno_[gob]; 
    816                 u_int nbit = ((bc_ - bs_) << 3) + nbb_; 
     582        u_int nbit; 
     583        u_int blkno; 
     584 
     585        for (u_int gob = 0; gob < ngob; gob ++) { 
     586 
     587                blkno = 33 * gob; 
    817588 
    818589                /* GSC/GN */ 
    819                 PUT_BITS(0x10 | (gob + 1), 20, nbb_, bb_, bc_); 
    820                 /* GQUANT/GEI */ 
    821                 mquant_ = lq_; 
    822                 PUT_BITS(mquant_ << 1, 6, nbb_, bb_, bc_); 
    823  
    824                 mba_ = 0; 
    825                 int line = 11; 
    826                 for (u_int mba = 1; mba <= 33; ++mba) { 
     590                PUT_BITS(0x0001, 16, nbb, bb, bc); 
     591                PUT_BITS(gob, 20, nbb, bb, bc); 
     592 
     593                /* GQUANT */ 
     594                mquant = lq; 
     595                PUT_BITS(mquant, 5, nbb, bb, bc); 
     596                mba = 0; 
     597 
     598 
     599                for (u_int mbal = 1; mbal <= 33 && blkno < nblocks; ++mbal, blkno++) { 
    827600                        /* 
    828601                         * If the conditional replenishment algorithm 
     
    833606 
    834607                        if ((s & CR_SEND) != 0) { 
    835                                 u_int mbpred = mba_; 
    836                                 encode_mb(mba, frm, loff, coff, CR_STATE(s)); 
    837                                 u_int cbits = ((bc_ - bs_) << 3) + nbb_; 
     608 
     609                                nbit = ((bc - bs) << 3) + nbb; 
     610                                encode_mb(mbal,  
     611                                          frm,  
     612                                          loff_table[blkno],  
     613                                          coff_table[blkno],  
     614                                          CR_STATE(crvec[blkno])); 
     615                                uint32_t cbits = ((bc - bs) << 3) + nbb; 
    838616                                if (cbits > ec) { 
    839                                         pktbuf* npb; 
    840                                         npb = pool_->alloc(vf->ts_, RTP_PT_H261); 
    841                                         cc += flush(pb, nbit, npb); 
    842                                         cbits -= nbit; 
     617                                        pktbuf *npb; 
     618                                        npb = pool_->alloc(vf->ts_,  
     619                                                           RTP_PT_H261AS); 
     620                                        cc += flush(pb,  
     621                                                    nbit,  
     622                                                    npb); 
    843623                                        pb = npb; 
    844                                         /* RTP/H.261 header */ 
    845                                         u_int m = mbpred; 
    846                                         u_int g; 
    847                                         if (m != 0) { 
    848                                                 g = gob + 1; 
    849                                                 m -= 1; 
    850                                         } else 
    851                                                 g = 0; 
    852  
    853                                         rh = (rtphdr*)pb->data; 
    854                                         *(u_int*)(rh + 1) = 
    855                                                 1 << 25 | 
    856                                                 m << 15 | 
    857                                                 g << 20 | 
    858                                                 mquant_ << 10; 
    859                                 } 
    860                                 nbit = cbits; 
     624           
     625                                        bs = &pb->data[HDRSIZE]; 
     626                                        bc = bs; 
     627                                        bb = 0; 
     628                                        nbb = 0; 
     629                                        sbit = 0; 
     630 
     631                                        rtphdr* rh = (rtphdr*)pb->data; 
     632                                        *(u_int*)(rh + 1) = lq << 24 | ((width >> 4) - 1) << 12 | ((height >> 4) - 1); 
     633 
     634 
     635 
     636                                        PUT_BITS(0x0001, 16, nbb, bb, bc); 
     637                                        PUT_BITS(gob, 20, nbb, bb, bc); 
     638                                        PUT_BITS(mquant, 5, nbb, bb, bc); 
     639 
     640                                        mba = 0; 
     641                                        encode_mb(mbal,  
     642                                                  frm,  
     643                                                  loff_table[blkno],  
     644                                                  coff_table[blkno],  
     645                                                  CR_STATE(crvec[blkno])); 
     646                                }  
    861647                        } 
    862  
    863                         loff += loffsize_; 
    864                         coff += coffsize_; 
    865                         blkno += bloffsize_; 
    866                         if (--line <= 0) { 
    867                                 line = 11; 
    868                                 blkno += bstride_; 
    869                                 loff += lstride_; 
    870                                 coff += cstride_; 
    871                         } 
    872  
    873648                } 
    874649        } 
    875         cc += flush(pb, ((bc_ - bs_) << 3) + nbb_, 0); 
     650 
     651        cc += flush(pb, ((bc - bs) << 3) + nbb, 0); 
     652 
    876653        return (cc); 
    877654} 
  • vic/trunk/rtp/rtp.h

    r3795 r3805  
    6060#define RTP_PT_H263P    42      /* ITU H.263 */ 
    6161#define RTP_PT_H263             34      /* ITU H.263 */ 
     62#define RTP_PT_DV               123     /* DV */ 
    6263 
    6364/* backward compat hack for decoding RTPv1 ivs streams */ 
  • vic/trunk/rtp/session.cpp

    r3798 r3805  
    8282                case RTP_PT_LDCT: 
    8383                case RTP_PT_PVH: 
     84                case RTP_PT_DV: 
    8485#ifdef USE_H261AS 
    8586                case RTP_PT_H261AS: 
  • vic/trunk/tcl/cf-main.tcl

    r3795 r3805  
    4848set rtp_type(127) h261v1 
    4949set rtp_type(77) h261as 
     50set rtp_type(123) dv 
    5051 
    5152proc vic_main {} {