root/vic/branches/cc/codec/encoder-h261.cpp @ 4782

Revision 4782, 25.5 KB (checked in by soohyunc, 4 years ago)

added a mechanism to adjust "quantizer":

as long as cwnd allows:
decrease quantizer to increase encoding bit rate when tx queue is small
increase quantizer to decrease encoding bit rate as tx queue fills

this, however, doesn't solve the tx queue fluctuating feature: tx queue will
fluctuate in anyway (fills up and drains repeatedly).

the point here is that we get a lot better video quality with this mechanism.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
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 */
34static const char rcsid[] =
35    "@(#) $Header$ (LBL)";
36
37#include <stdio.h>
38#include <stdlib.h>
39#include <string.h>
40#include <errno.h>
41#include "inet.h"
42#include "net.h"
43#include "rtp.h"
44#include "dct.h"
45#include "p64/p64-huff.h"
46#include "bsd-endian.h"
47#include "vic_tcl.h"
48#include "crdef.h"
49#include "transmitter.h"
50#include "pktbuf-rtp.h"
51#include "module.h"
52
53#define HDRSIZE (sizeof(rtphdr) + 4)
54#define CIF_WIDTH       352
55#define CIF_HEIGHT      288
56#define QCIF_WIDTH      176
57#define QCIF_HEIGHT     144
58#define BMB             6       /* # blocks in a MB */
59#define MBPERGOB        33      /* # of Macroblocks per GOB */
60
61#ifdef INT_64
62#define NBIT 64
63#define BB_INT INT_64
64#else
65#define NBIT 32
66#define BB_INT u_int
67#endif
68
69#if BYTE_ORDER == LITTLE_ENDIAN
70#if NBIT == 64
71#define STORE_BITS(bb, bc) \
72        bc[0] = bb >> 56; \
73        bc[1] = bb >> 48; \
74        bc[2] = bb >> 40; \
75        bc[3] = bb >> 32; \
76        bc[4] = bb >> 24; \
77        bc[5] = bb >> 16; \
78        bc[6] = bb >> 8; \
79        bc[7] = bb;
80#define LOAD_BITS(bc) \
81        ((BB_INT)bc[0] << 56 | \
82         (BB_INT)bc[1] << 48 | \
83         (BB_INT)bc[2] << 40 | \
84         (BB_INT)bc[3] << 32 | \
85         (BB_INT)bc[4] << 24 | \
86         (BB_INT)bc[5] << 16 | \
87         (BB_INT)bc[6] << 8 | \
88         (BB_INT)bc[7])
89#else
90#define STORE_BITS(bb, bc) \
91        bc[0] = bb >> 24; \
92        bc[1] = bb >> 16; \
93        bc[2] = bb >> 8; \
94        bc[3] = bb;
95#define LOAD_BITS(bc) (ntohl(*(BB_INT*)(bc)))
96#endif
97#else
98#define STORE_BITS(bb, bc) *(BB_INT*)bc = (bb);
99#define LOAD_BITS(bc) (*(BB_INT*)(bc))
100#endif
101
102#define PUT_BITS(bits, n, nbb, bb, bc) \
103{ \
104        nbb += (n); \
105        if (nbb > NBIT)  { \
106                u_int extra = (nbb) - NBIT; \
107                bb |= (BB_INT)(bits) >> extra; \
108                STORE_BITS(bb, bc) \
109                bc += sizeof(BB_INT); \
110                bb = (BB_INT)(bits) << (NBIT - extra); \
111                nbb = extra; \
112        } else \
113                bb |= (BB_INT)(bits) << (NBIT - (nbb)); \
114}
115
116// frame history size to keep track the number of packets per frame
117#define FHSIZE  10
118
119class H261Encoder : public TransmitterModule {
120    public:
121        void setq(int q);
122        int quantizer_;
123
124        // Tx pktbuf size
125        int txq_beg_;
126        int txq_end_;
127        int txq_dif_;
128        // number of transmitted packets for this round of encoding
129        int num_sent_;
130        // number of sent packets in between two encoding instances
131        // (these packets were sent from the Tx queue upon XR reception)
132        int sent_more_;
133        // packets per frame
134        int ppframe_[FHSIZE];
135        inline void init_ppframe() {
136                for (int i = 0; i < FHSIZE; i++)
137                ppframe_[i] = 0;
138        }
139        // video frame number
140        int vfno_;
141
142        // should we suspend grabbing?
143        virtual bool suspend_grabbing(int m);
144        // adjust quantizer
145        void adjust_quantizer(int txq, int avg);
146
147    protected:
148        H261Encoder(int ft);
149        ~H261Encoder();
150        int encode(const VideoFrame*, const u_int8_t *crvec);
151        int command(int argc, const char*const* argv);
152        void encode_blk(const short* blk, const char* lm);
153        int flush(pktbuf* pb, int nbit, pktbuf* npb);
154        char* make_level_map(int q, u_int fthresh);
155        void setquantizers(int lq, int mq, int hq);
156
157        virtual void size(int w, int h) = 0;
158        virtual void encode_mb(u_int mba, const u_char* frm,
159                       u_int loff, u_int coff, int how) = 0;
160
161        double enc_start_;      // encoding start timestamp
162        double enc_end_;        // encoding end timestamp
163
164        /* bit buffer */
165        BB_INT bb_;
166        u_int nbb_;
167
168        u_char* bs_;
169        u_char* bc_;
170        int sbit_;
171
172        u_char lq_;             /* low quality quantizer */
173        u_char mq_;             /* medium quality quantizer */
174        u_char hq_;             /* high quality quantizer */
175        u_char mquant_;         /* the last quantizer we sent to other side */
176        int quant_required_;    /* 1 if not quant'd in dct */
177        u_int ngob_;
178        u_int mba_;
179
180        u_int cif_;             /* 1 for CIF, 0 for QCIF */
181        u_int bstride_;
182        u_int lstride_;
183        u_int cstride_;
184
185        u_int loffsize_;        /* amount of 1 luma block */
186        u_int coffsize_;        /* amount of 1 chroma block */
187        u_int bloffsize_;       /* amount of 1 block advance */
188
189        const char* llm_[32];   /* luma dct val -> level maps */
190        const char* clm_[32];   /* chroma dct val -> level maps */
191
192        float lqt_[64];         /* low quality quantizer */
193        float mqt_[64];         /* medium quality quantizer */
194        float hqt_[64];         /* high quality quantizer */
195
196        u_int coff_[12];        /* where to find U given gob# */
197        u_int loff_[12];        /* where to find Y given gob# */
198        u_int blkno_[12];       /* for CR */
199
200        // average number of packets per frame
201        int avg_packets_per_frame();
202
203        // print Tx queue info
204        inline void print_txq_info() {
205        fprintf(stderr, "   now: %f\ttxq_now: %d\n",
206        get_now(), tx_->tx_buf_size());
207        }
208        inline void print_txq_info(int len) {
209        fprintf(stderr, "   now: %f\ttxq_now: %d\n",
210        get_now(), len);
211        }
212        inline void print_txq_info(int len, int dif) {
213        fprintf(stderr, "   now: %f\ttxq_now: %d\tdif: %d\n",
214        get_now(), len, dif);
215        }
216        // print Tx queue sent more
217        inline void print_sent_more() {
218        fprintf(stderr, "\tnow: %f\tsent: %d more: %d vf[%d]: %d\n",
219        get_now(), num_sent_, sent_more_,
220        vfno_%FHSIZE, ppframe_[vfno_%FHSIZE]);
221        }
222        // print encoding time
223        inline void print_enc_time() {
224        fprintf(stderr, "   now: %f\tenc_time: %f\n\n",
225        get_now(), (enc_end_ - enc_start_));
226        }
227        // print packers per frame
228        inline void print_ppframe() {
229        fprintf(stderr, "\tnow: %f\tppframe[%d]: %d\n",
230        get_now(), vfno_%FHSIZE, ppframe_[vfno_%FHSIZE]);
231        }
232        // print setq time
233        inline void print_time_setq(int quant, double time) {
234        fprintf(stderr, "now: %f duration: %f quant: %d\n",
235        get_now(), get_now() - time, quant);
236        }
237
238private:
239};
240
241class H261DCTEncoder : public H261Encoder {
242    public:
243        H261DCTEncoder();
244        int consume(const VideoFrame*);
245        void size(int w, int h);
246    protected:
247        void encode_mb(u_int mba, const u_char* frm,
248                       u_int loff, u_int coff, int how);
249};
250
251class H261PixelEncoder : public H261Encoder {
252    public:
253        H261PixelEncoder();
254        int consume(const VideoFrame*);
255        void size(int w, int h);
256    protected:
257        void encode_mb(u_int mba, const u_char* frm,
258                       u_int loff, u_int coff, int how);
259};
260
261static class H261EncoderMatcher : public Matcher {
262    public:
263        H261EncoderMatcher() : Matcher("module") {}
264        TclObject* match(const char* fmt) {
265                if (strcasecmp(fmt, "h261/pixel") == 0)
266                        return (new H261PixelEncoder);
267                if (strcasecmp(fmt, "h261/dct") == 0)
268                        return (new H261DCTEncoder);
269                /* XXX for now, this is compatible with ui-ctrlmenu.tcl */
270                if (strcasecmp(fmt, "h261") == 0)
271                        return (new H261PixelEncoder);
272                return (0);
273        }
274} encoder_matcher_h261;
275
276
277H261Encoder::H261Encoder(int ft) : TransmitterModule(ft),
278        bs_(0), bc_(0), ngob_(12)
279{
280        // h261 gettimeofday
281        enc_start_ = 0.0;
282        enc_end_ = 0.0;
283
284        // Tx pktbuf size
285        txq_beg_ = 0;
286        txq_end_ = 0;
287        txq_dif_ = 0;
288        // number of transmitted packets for this round of encoding
289        num_sent_ = 0;
290        // number of sent packets in between two encoding instances
291        // (these packets were sent from the Tx queue upon XR reception)
292        sent_more_ = 0;
293
294        // packets per frame
295        init_ppframe();
296        // video frame number
297        vfno_ = 0;
298
299        for (int q = 0; q < 32; ++q) {
300                llm_[q] = 0;
301                clm_[q] = 0;
302        }
303}
304
305H261Encoder::~H261Encoder()
306{
307        for (int q = 0; q < 32; ++q) {
308                if (llm_[q] != 0)
309                        delete llm_[q]; //SV-XXX: Debian
310                if (clm_[q] != 0)
311                        delete clm_[q]; //SV-XXX: Debian
312        }
313}
314
315H261PixelEncoder::H261PixelEncoder() : H261Encoder(FT_YUV_CIF)
316{
317        quant_required_ = 0;
318        quantizer_ = 10;
319        setq(quantizer_);
320}
321
322H261DCTEncoder::H261DCTEncoder() : H261Encoder(FT_DCT)
323{
324        quant_required_ = 1;
325        quantizer_ = 10;
326        setq(quantizer_);
327}
328
329/*
330 * Set up the forward DCT quantization table for
331 * INTRA mode operation.
332 */
333void
334H261Encoder::setquantizers(int lq, int mq, int hq)
335{
336        int qt[64];
337        if (lq > 31)
338                lq = 31;
339        if (lq <= 0)
340                lq = 1;
341        lq_ = lq;
342
343        if (mq > 31)
344                mq = 31;
345        if (mq <= 0)
346                mq = 1;
347        mq_ = mq;
348
349        if (hq > 31)
350                hq = 31;
351        if (hq <= 0)
352                hq = 1;
353        hq_ = hq;
354
355        /*
356         * quant_required_ indicates quantization is not folded
357         * into fdct [because fdct is not performed]
358         */
359        if (quant_required_ == 0) {
360                /*
361                 * Set the DC quantizer to 1, since we want to do this
362                 * coefficient differently (i.e., the DC is rounded while
363                 * the AC terms are truncated).
364                 */
365                qt[0] = 1;
366                int i;
367                for (i = 1; i < 64; ++i)
368                        qt[i] = lq_ << 1;
369                fdct_fold_q(qt, lqt_);
370
371                qt[0] = 1;
372                for (i = 1; i < 64; ++i)
373                        qt[i] = mq_ << 1;
374                fdct_fold_q(qt, mqt_);
375
376                qt[0] = 1;
377                for (i = 1; i < 64; ++i)
378                        qt[i] = hq_ << 1;
379                fdct_fold_q(qt, hqt_);
380        }
381}
382
383void
384H261Encoder::setq(int q)
385{
386        setquantizers(q, q / 2, 1);
387}
388
389void
390H261PixelEncoder::size(int w, int h)
391{
392        Module::size(w, h);
393        if (w == CIF_WIDTH && h == CIF_HEIGHT) {
394                /* CIF */
395                cif_ = 1;
396                ngob_ = 12;
397                bstride_ = 11;
398                lstride_ = 16 * CIF_WIDTH - CIF_WIDTH / 2;
399                cstride_ = 8 * 176 - 176 / 2;
400                loffsize_ = 16;
401                coffsize_ = 8;
402                bloffsize_ = 1;
403        } else if (w == QCIF_WIDTH && h == QCIF_HEIGHT) {
404                /* QCIF */
405                cif_ = 0;
406                ngob_ = 6; /* not really number of GOBs, just loop limit */
407                bstride_ = 0;
408                lstride_ = 16 * QCIF_WIDTH - QCIF_WIDTH;
409                cstride_ = 8 * 88 - 88;
410                loffsize_ = 16;
411                coffsize_ = 8;
412                bloffsize_ = 1;
413        } else {
414                /*XXX*/
415                fprintf(stderr, "H261PixelEncoder: H.261 bad geometry: %dx%d\n",
416                        w, h);
417                exit(1);
418        }
419        u_int loff = 0;
420        u_int coff = 0;
421        u_int blkno = 0;
422        for (u_int gob = 0; gob < ngob_; gob += 2) {
423                loff_[gob] = loff;
424                coff_[gob] = coff;
425                blkno_[gob] = blkno;
426                /* width of a GOB (these aren't ref'd in QCIF case) */
427                loff_[gob + 1] = loff + 11 * 16;
428                coff_[gob + 1] = coff + 11 * 8;
429                blkno_[gob + 1] = blkno + 11;
430
431                /* advance to next GOB row */
432                loff += (16 * 16 * MBPERGOB) << cif_;
433                coff += (8 * 8 * MBPERGOB) << cif_;
434                blkno += MBPERGOB << cif_;
435        }
436}
437
438void
439H261DCTEncoder::size(int w, int h)
440{
441
442        Module::size(w, h);
443        if (w == CIF_WIDTH && h == CIF_HEIGHT) {
444                /* CIF */
445                cif_ = 1;
446                ngob_ = 12;
447                bstride_ = 11;
448                lstride_ = - (11 * (64*BMB)) + 2 * 11 * 64 * BMB;
449                cstride_ = - (11 * (64*BMB)) + 2 * 11 * 64 * BMB;
450                loffsize_ = 64 * BMB;
451                coffsize_ = 64 * BMB;
452                bloffsize_ = 1;
453        } else if (w == QCIF_WIDTH && h == QCIF_HEIGHT) {
454                /* QCIF */
455                cif_ = 0;
456                ngob_ = 6; /* not really number of GOBs, just loop limit */
457                bstride_ = 0;
458                lstride_ = 0;
459                cstride_ = 0;
460                loffsize_ = 64 * BMB;
461                coffsize_ = 64 * BMB;
462                bloffsize_ = 1;
463        } else {
464                /*XXX*/
465                fprintf(stderr, "H261DCTEncoder: H.261 bad geometry: %dx%d\n",
466                        w, h);
467                exit(1);
468        }
469
470        u_int gob;
471        for (gob = 0; gob < ngob_; gob += 2) {
472
473                if (gob != 0) {
474                        loff_[gob] = loff_[gob-2] +
475                                (MBPERGOB << cif_) * BMB * 64;
476                        coff_[gob] = coff_[gob-2] +
477                                (MBPERGOB << cif_) * BMB * 64;
478                        blkno_[gob] = blkno_[gob-2] +
479                                (MBPERGOB << cif_);
480                } else {
481                        loff_[0] = 0;
482                        coff_[0] = loff_[0] + 4 * 64;   // 4 Y's
483                        blkno_[0] = 0;
484                }
485
486                loff_[gob + 1] = loff_[gob] + 11 * BMB * 64;
487                coff_[gob + 1] = coff_[gob] + 11 * BMB * 64;
488                blkno_[gob + 1] = blkno_[gob] + 11;
489        }
490}
491
492
493int
494H261Encoder::command(int argc, const char*const* argv)
495{
496        if (argc == 3 && strcmp(argv[1], "q") == 0) {
497                quantizer_ = atoi(argv[2]);
498                setq(quantizer_);
499                return (TCL_OK);
500        }
501        return (TransmitterModule::command(argc, argv));
502}
503
504/*
505 * Make a map to go from a 12 bit dct value to an 8 bit quantized
506 * 'level' number.  The 'map' includes both the quantizer (for the
507 * dct encoder) and the perceptual filter 'threshhold' (for both
508 * the pixel & dct encoders).  The first 4k of the map is for the
509 * unfiltered coeff (the first 20 in zigzag order; roughly the
510 * upper left quadrant) and the next 4k of the map are for the
511 * filtered coef.
512 */
513char*
514H261Encoder::make_level_map(int q, u_int fthresh)
515{
516        /* make the luminance map */
517        char* lm = new char[0x2000];
518        char* flm = lm + 0x1000;
519        int i;
520        lm[0] = 0;
521        flm[0] = 0;
522        q = quant_required_? q << 1 : 0;
523        for (i = 1; i < 0x800; ++i) {
524                int l = i;
525                if (q)
526                        l /= q;
527                lm[i] = l;
528                lm[-i & 0xfff] = -l;
529
530                if ((u_int)l <= fthresh)
531                        l = 0;
532                flm[i] = l;
533                flm[-i & 0xfff] = -l;
534        }
535        return (lm);
536}
537
538/*
539 * encode_blk:
540 *      encode a block of DCT coef's
541 */
542void
543H261Encoder::encode_blk(const short* blk, const char* lm)
544{
545        BB_INT bb = bb_;
546        u_int nbb = nbb_;
547        u_char* bc = bc_;
548
549        /*
550         * Quantize DC.  Round instead of truncate.
551         */
552        int dc = (blk[0] + 4) >> 3;
553
554        if (dc <= 0)
555                /* shouldn't happen with CCIR 601 black (level 16) */
556                dc = 1;
557        else if (dc > 254)
558                dc = 254;
559        else if (dc == 128)
560                /* per Table 6/H.261 */
561                dc = 255;
562        /* Code DC */
563        PUT_BITS(dc, 8, nbb, bb, bc);
564        int run = 0;
565        const u_char* colzag = &COLZAG[0];
566        for (int zag; (zag = *++colzag) != 0; ) {
567                if (colzag == &COLZAG[20])
568                        lm += 0x1000;
569                int level = lm[((const u_short*)blk)[zag] & 0xfff];
570                if (level != 0) {
571                        int val, nb;
572                        huffent* he;
573                        if (u_int(level + 15) <= 30 &&
574                            (nb = (he = &hte_tc[((level&0x1f) << 6)|run])->nb))
575                                /* we can use a VLC. */
576                                val = he->val;
577                        else {
578                                 /* Can't use a VLC.  Escape it. */
579                                val = (1 << 14) | (run << 8) | (level & 0xff);
580                                nb = 20;
581                        }
582                        PUT_BITS(val, nb, nbb, bb, bc);
583                        run = 0;
584                } else
585                        ++run;
586        }
587        /* EOB */
588        PUT_BITS(2, 2, nbb, bb, bc);
589
590        bb_ = bb;
591        nbb_ = nbb;
592        bc_ = bc;
593}
594
595/*
596 * H261PixelEncoder::encode_mb
597 *      encode a macroblock given a set of input YUV pixels
598 */
599void
600H261PixelEncoder::encode_mb(u_int mba, const u_char* frm,
601                            u_int loff, u_int coff, int how)
602{
603        register int q;
604        float* qt;
605        if (how == CR_MOTION) {
606                q = lq_;
607                qt = lqt_;
608        } else if (how == CR_BG) {
609                q = hq_;
610                qt = hqt_;
611        } else {
612                /* must be at age threshold */
613                q = mq_;
614                qt = mqt_;
615        }
616
617        /*
618         * encode all 6 blocks of the macro block to find the largest
619         * coef (so we can pick a new quantizer if gquant doesn't have
620         * enough range).
621         */
622        /*XXX this can be u_char instead of short but need smarts in fdct */
623        short blk[64 * 6];
624        register int stride = width_;
625        /* luminance */
626        const u_char* p = &frm[loff];
627        fdct(p, stride, blk + 0, qt);
628        fdct(p + 8, stride, blk + 64, qt);
629        fdct(p + 8 * stride, stride, blk + 128, qt);
630        fdct(p + (8 * stride + 8), stride, blk + 192, qt);
631        /* chominance */
632        int fs = framesize_;
633        p = &frm[fs + coff];
634        stride >>= 1;
635        fdct(p, stride, blk + 256, qt);
636        fdct(p + (fs >> 2), stride, blk + 320, qt);
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 = blk;
646                for (register int i = 6; --i >= 0; ) {
647                        ++bp;   // ignore dc coef
648                        for (register int j = 63; --j >= 0; ) {
649                                register int v = *bp++;
650                                if (v < cmin)
651                                        cmin = v;
652                                else if (v > cmax)
653                                        cmax = v;
654                        }
655                }
656                if (cmax < -cmin)
657                        cmax = -cmin;
658                if (cmax >= 128) {
659                        /* need to re-quantize */
660                        register int s;
661                        for (s = 1; cmax >= (128 << s); ++s) {
662                        }
663                        q <<= s;
664                        register short* bp = blk;
665                        for (register int i = 6; --i >= 0; ) {
666                                ++bp;   // ignore dc coef
667                                for (register int j = 63; --j >= 0; ) {
668                                        register int v = *bp;
669                                        *bp++ = v >> s;
670                                }
671                        }
672                }
673        }
674
675        u_int m = mba - mba_;
676        mba_ = mba;
677        huffent* he = &hte_mba[m - 1];
678        /* MBA */
679        PUT_BITS(he->val, he->nb, nbb_, bb_, bc_);
680        if (q != mquant_) {
681                /* MTYPE = INTRA + TC + MQUANT */
682                PUT_BITS(1, 7, nbb_, bb_, bc_);
683                PUT_BITS(q, 5, nbb_, bb_, bc_);
684                mquant_ = q;
685        } else {
686                /* MTYPE = INTRA + TC (no quantizer) */
687                PUT_BITS(1, 4, nbb_, bb_, bc_);
688        }
689
690        /* luminance */
691        const char* lm = llm_[q];
692        if (lm == 0) {
693                lm = make_level_map(q, 1);
694                llm_[q] = lm;
695                clm_[q] = make_level_map(q, 2);
696        }
697        encode_blk(blk + 0, lm);
698        encode_blk(blk + 64, lm);
699        encode_blk(blk + 128, lm);
700        encode_blk(blk + 192, lm);
701        /* chominance */
702        lm = clm_[q];
703        encode_blk(blk + 256, lm);
704        encode_blk(blk + 320, lm);
705}
706
707
708/*
709 * H261DCTEncoder::encode_mb
710 *      encode a macroblock given a set of input DCT coefs
711 *      each coef is stored as a short
712 */
713void
714H261DCTEncoder::encode_mb(u_int mba, const u_char* frm,
715                          u_int loff, u_int coff, int how)
716{
717        short *lblk = (short *)frm + loff;
718        short *ublk = (short *)frm + coff;
719        short *vblk = (short *)frm + coff + 64;
720
721        register u_int q;
722        if (how == CR_MOTION)
723                q = lq_;
724        else if (how == CR_BG)
725                q = hq_;
726        else
727                /* must be at age threshold */
728                q = mq_;
729
730        /*
731         * if the default quantizer is too small to handle the coef.
732         * dynamic range, spin through the blocks and see if any
733         * coef. would significantly overflow.
734         */
735        if (q < 8) {
736                register int cmin = 0, cmax = 0;
737                register short* bp = lblk;
738                register int i, j;
739
740                // Y U and V blocks
741                for (i = 6; --i >= 0; ) {
742                        ++bp;   // ignore dc coef
743                        for (j = 63; --j >= 0; ) {
744                                register int v = *bp++;
745                                if (v < cmin)
746                                        cmin = v;
747                                else if (v > cmax)
748                                        cmax = v;
749                        }
750                }
751
752                if (cmax < -cmin)
753                        cmax = -cmin;
754                cmax /= (q << 1);
755                if (cmax >= 128) {
756                        /* need to re-quantize */
757                        register int s;
758
759                        for (s = 1; cmax >= (128 << s); ++s) {
760                        }
761                        q <<= s;
762
763                }
764        }
765
766        u_int m = mba - mba_;
767        mba_ = mba;
768        huffent* he = &hte_mba[m - 1];
769        /* MBA */
770        PUT_BITS(he->val, he->nb, nbb_, bb_, bc_);
771        if (q != mquant_) {
772                /* MTYPE = INTRA + TC + MQUANT */
773                PUT_BITS(1, 7, nbb_, bb_, bc_);
774                PUT_BITS(q, 5, nbb_, bb_, bc_);
775                mquant_ = q;
776        } else {
777                /* MTYPE = INTRA + TC (no quantizer) */
778                PUT_BITS(1, 4, nbb_, bb_, bc_);
779        }
780
781        /* luminance */
782        const char* lm = llm_[q];
783        if (lm == 0) {
784                /*
785                 * the filter thresh is 0 since we assume the jpeg percept.
786                 * quantizer already did the filtering.
787                 */
788                lm = make_level_map(q, 0);
789                llm_[q] = lm;
790                clm_[q] = make_level_map(q, 0);
791        }
792        encode_blk(lblk + 0, lm);
793        encode_blk(lblk + 64, lm);
794        encode_blk(lblk + 128, lm);
795        encode_blk(lblk + 192, lm);
796        /* chominance */
797        lm = clm_[q];
798        encode_blk(ublk, lm);
799        encode_blk(vblk, lm);
800}
801
802int
803H261Encoder::flush(pktbuf* pb, int nbit, pktbuf* npb)
804{
805        //fprintf(stderr,"\nH261Encoder flush()\n");
806        /* flush bit buffer */
807        STORE_BITS(bb_, bc_);
808
809        int cc = (nbit + 7) >> 3;
810        int ebit = (cc << 3) - nbit;
811
812        /*XXX*/
813        if (cc == 0 && npb != 0)
814                abort();
815
816        pb->len = cc + HDRSIZE;
817        rtphdr* rh = (rtphdr*)pb->data;
818        if (npb == 0)
819                rh->rh_flags |= htons(RTP_M);
820
821        int h = *(u_int*)(rh + 1) | ebit << 26 | sbit_ << 29;
822        *(u_int*)(rh + 1) = htonl(h);
823
824        if (npb != 0) {
825                u_char* nbs = &npb->data[HDRSIZE];
826                u_int bc = (bc_ - bs_) << 3;
827                int tbit = bc + nbb_;
828                int extra = ((tbit + 7) >> 3) - (nbit >> 3);
829                if (extra > 0)
830                        memcpy(nbs, bs_ + (nbit >> 3), extra);
831                bs_ = nbs;
832                sbit_ = nbit & 7;
833                tbit -= nbit &~ 7;
834                bc = tbit &~ (NBIT - 1);
835                nbb_ = tbit - bc;
836                bc_ = bs_ + (bc >> 3);
837                /*
838                 * Prime the bit buffer.  Be careful to set bits that
839                 * are not yet in use to 0, since output bits are later
840                 * or'd into the buffer.
841                 */
842                if (nbb_ > 0) {
843                        u_int n = NBIT - nbb_;
844                        bb_ = (LOAD_BITS(bc_) >> n) << n;
845                } else
846                        bb_ = 0;
847        }
848        // increment the number of packets for this frame
849        ppframe_[vfno_%FHSIZE]++;
850        print_ppframe();
851
852        tx_->send(pb);
853
854        return (cc + HDRSIZE);
855}
856
857int H261DCTEncoder::consume(const VideoFrame *vf)
858{
859        if (!samesize(vf))
860                size(vf->width_, vf->height_);
861
862        DCTFrame* df = (DCTFrame *)vf;
863
864        return(encode(df, df->crvec_));
865}
866
867int H261PixelEncoder::consume(const VideoFrame *vf)
868{
869        // adjust timestamp offset
870        tx_->tx_now_offset_ = offset();
871
872        // (get the necessary stats before encoding) ---------------------*
873        // Tx queue size before entering this encoding
874        txq_beg_ = tx_->tx_buf_size();
875        print_txq_info(txq_beg_);
876        // sent packets after the previous encoding round,
877        // but before starting this encoding instance.
878        // -- these packets were sent from the Tx queue
879        //    upon XR reception in between two encoding instances.
880        sent_more_ = txq_end_ - txq_beg_;
881        print_sent_more();
882
883        // all encoded packets associated with
884        // the previously captured frame have been sent
885        if (num_sent_ + sent_more_ == ppframe_[vfno_%FHSIZE]) {
886        }
887        // some packets associated with
888        // the previously captured frame have not been sent
889        if (num_sent_ + sent_more_ < ppframe_[vfno_%FHSIZE]) {
890        }
891        // more packets have been sent than the encoded packets
892        // perhaps, there were some packets in the tx queue, and
893        // cwnd has been increrased allowing sending them all.
894        if (num_sent_ + sent_more_ > ppframe_[vfno_%FHSIZE]) {
895        }
896        // ---------------------------------------------------------------*
897
898        // adjust quantizer
899        adjust_quantizer(txq_beg_, avg_packets_per_frame());
900
901        // increment frame number
902        if (vfno_++%FHSIZE == 0)
903        init_ppframe();
904
905        // check size
906        if (!samesize(vf))
907                size(vf->width_, vf->height_);
908
909        // main encoding loop
910        // (send packets while encoding)
911        YuvFrame* p = (YuvFrame*)vf;
912        int cc = encode(p, p->crvec_);
913
914        // Tx queue size after finishing encoding
915        txq_end_ = tx_->tx_buf_size();
916        txq_dif_ = txq_end_ - txq_beg_;
917        // number of Tx'd packets during this encoding instance
918        // (these Tx'd packets may include the previous frame(s).)
919        num_sent_ = ppframe_[vfno_%FHSIZE] - txq_dif_;
920
921        print_txq_info(txq_end_, txq_dif_);
922        print_enc_time();
923
924        return(cc);
925}
926
927/*
928 * adjust quantizer depending on the current tx queue size by comparing the
929 * average number of packets per frame
930 * @txq: tx queue size
931 * @avg: average number of packets per frame
932 *       (most recent 10 frames only)
933 */
934void
935H261Encoder::adjust_quantizer(int txq, int avg)
936{
937        double time = get_now();
938
939        if (txq < avg) {
940                quantizer_ = (--quantizer_ < 3) ? 3 : quantizer_;
941                setq(quantizer_);
942                //print_time_setq(quantizer_, time);
943        }
944        else if (txq >= avg && txq < 3.5 * avg) {
945                quantizer_++;
946                setq(quantizer_);
947                //print_time_setq(quantizer_, time);
948        }
949        else {
950                quantizer_ += 2;
951                setq(quantizer_);
952                //print_time_setq(quantizer_, time);
953        }
954}
955
956int
957H261Encoder::encode(const VideoFrame* vf, const u_int8_t *crvec)
958{
959        // time measurement
960        enc_start_ = get_now();
961        fprintf(stderr,">>>h261_encode_start\tnow: %f\n", enc_start_);
962
963        tx_->flush();
964
965        pktbuf* pb = pool_->alloc(vf->ts_, RTP_PT_H261);
966        bs_ = &pb->data[HDRSIZE];
967        bc_ = bs_;
968        u_int ec = (tx_->mtu() - HDRSIZE) << 3;
969        bb_ = 0;
970        nbb_ = 0;
971        sbit_ = 0;
972        /* RTP/H.261 header */
973        rtphdr* rh = (rtphdr*)pb->data;
974        *(u_int*)(rh + 1) = 1 << 25 | lq_ << 10;
975
976        /* PSC */
977        PUT_BITS(0x0001, 16, nbb_, bb_, bc_);
978        /* GOB 0 -> picture header */
979        PUT_BITS(0, 4, nbb_, bb_, bc_);
980        /* TR (XXX should do this right) */
981        PUT_BITS(0, 5, nbb_, bb_, bc_);
982        /* PTYPE = CIF */
983        int pt = cif_ ? 4 : 0;
984        PUT_BITS(pt, 6, nbb_, bb_, bc_);
985        /* PEI */
986        PUT_BITS(0, 1, nbb_, bb_, bc_);
987
988        int step = cif_ ? 1 : 2;
989        int cc = 0;
990
991        u_int8_t* frm = vf->bp_;
992        for (u_int gob = 0; gob < ngob_; gob += step) {
993                u_int loff = loff_[gob];
994                u_int coff = coff_[gob];
995                u_int blkno = blkno_[gob];
996                u_int nbit = ((bc_ - bs_) << 3) + nbb_;
997
998                /* GSC/GN */
999                PUT_BITS(0x10 | (gob + 1), 20, nbb_, bb_, bc_);
1000                /* GQUANT/GEI */
1001                mquant_ = lq_;
1002                PUT_BITS(mquant_ << 1, 6, nbb_, bb_, bc_);
1003
1004                mba_ = 0;
1005                int line = 11;
1006                for (u_int mba = 1; mba <= 33; ++mba) {
1007                        /*
1008                         * If the conditional replenishment algorithm
1009                         * has decided to send any of the blocks of
1010                         * this macroblock, code it.
1011                         */
1012                        u_int s = crvec[blkno];
1013
1014                        if ((s & CR_SEND) != 0) {
1015                                u_int mbpred = mba_;
1016                                encode_mb(mba, frm, loff, coff, CR_STATE(s));
1017                                u_int cbits = ((bc_ - bs_) << 3) + nbb_;
1018                                if (cbits > ec) {
1019                                        pktbuf* npb;
1020                                        npb = pool_->alloc(vf->ts_, RTP_PT_H261);
1021                                        cc += flush(pb, nbit, npb);
1022                                        cbits -= nbit;
1023                                        pb = npb;
1024                                        /* RTP/H.261 header */
1025                                        u_int m = mbpred;
1026                                        u_int g;
1027                                        if (m != 0) {
1028                                                g = gob + 1;
1029                                                m -= 1;
1030                                        } else
1031                                                g = 0;
1032
1033                                        rh = (rtphdr*)pb->data;
1034                                        *(u_int*)(rh + 1) =
1035                                                1 << 25 |
1036                                                m << 15 |
1037                                                g << 20 |
1038                                                mquant_ << 10;
1039                                }
1040                                nbit = cbits;
1041                        }
1042
1043                        loff += loffsize_;
1044                        coff += coffsize_;
1045                        blkno += bloffsize_;
1046                        if (--line <= 0) {
1047                                line = 11;
1048                                blkno += bstride_;
1049                                loff += lstride_;
1050                                coff += cstride_;
1051                        }
1052
1053                }
1054        }
1055        cc += flush(pb, ((bc_ - bs_) << 3) + nbb_, 0);
1056
1057        // time measurement
1058        enc_end_ = get_now();
1059        fprintf(stderr,"\n>>>h261_encode_end\tnow: %f\n", enc_end_);
1060
1061        return (cc);
1062}
1063
1064/*
1065 * average number of packets per frame
1066 */
1067int H261Encoder::avg_packets_per_frame() {
1068        int num = 0;
1069        int k = (vfno_ < FHSIZE) ? vfno_ : FHSIZE;
1070        if (k < 1) return 1;
1071
1072        for (int i = 0; i < k; i++)
1073                num += ppframe_[vfno_%FHSIZE];
1074
1075        return (num /= k);
1076}
1077
1078/*
1079 * if Tx queue is building up more than 5 frames, roughly,
1080 * then we should suspend grabbing to prevent it from growing up forever.
1081 */
1082bool H261Encoder::suspend_grabbing(int m) {
1083        // Tx queue len (in packets) at the time of calling this method
1084        int txq = tx_->tx_buf_size();
1085        // highest watermark
1086        int highmark = 0;
1087
1088        if (vfno_ < FHSIZE)
1089        return false;
1090
1091        // now, highmark is set to "m * (num packets per frame)",
1092        // which roughly represents "m" frames.
1093        highmark = m * avg_packets_per_frame();
1094
1095        if (txq > highmark)
1096                return true;
1097
1098        return false;
1099}
Note: See TracBrowser for help on using the browser.