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

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

create a field in pktbuf (i.e., bool tag) to indicate if this packet belongs to
the same video frame or not.

  • if tag is set (true), then this packets belong to the same frame.
  • if tag is set to false at the very last packets for the frame.

based on this information, CC module can compute the average packet size in
bytes.

  • first, compute the arithmetic average packet size per frame
  • then, use this average size to compute EWMA packet size

then, cwnd (in bytes) can be computed:

  • cwnd (in bytes) = psize * cwnd (in packets)
  • 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        pb->tag = true;
967        bs_ = &pb->data[HDRSIZE];
968        bc_ = bs_;
969        u_int ec = (tx_->mtu() - HDRSIZE) << 3;
970        bb_ = 0;
971        nbb_ = 0;
972        sbit_ = 0;
973        /* RTP/H.261 header */
974        rtphdr* rh = (rtphdr*)pb->data;
975        *(u_int*)(rh + 1) = 1 << 25 | lq_ << 10;
976
977        /* PSC */
978        PUT_BITS(0x0001, 16, nbb_, bb_, bc_);
979        /* GOB 0 -> picture header */
980        PUT_BITS(0, 4, nbb_, bb_, bc_);
981        /* TR (XXX should do this right) */
982        PUT_BITS(0, 5, nbb_, bb_, bc_);
983        /* PTYPE = CIF */
984        int pt = cif_ ? 4 : 0;
985        PUT_BITS(pt, 6, nbb_, bb_, bc_);
986        /* PEI */
987        PUT_BITS(0, 1, nbb_, bb_, bc_);
988
989        int step = cif_ ? 1 : 2;
990        int cc = 0;
991
992        u_int8_t* frm = vf->bp_;
993        for (u_int gob = 0; gob < ngob_; gob += step) {
994                u_int loff = loff_[gob];
995                u_int coff = coff_[gob];
996                u_int blkno = blkno_[gob];
997                u_int nbit = ((bc_ - bs_) << 3) + nbb_;
998
999                /* GSC/GN */
1000                PUT_BITS(0x10 | (gob + 1), 20, nbb_, bb_, bc_);
1001                /* GQUANT/GEI */
1002                mquant_ = lq_;
1003                PUT_BITS(mquant_ << 1, 6, nbb_, bb_, bc_);
1004
1005                mba_ = 0;
1006                int line = 11;
1007                for (u_int mba = 1; mba <= 33; ++mba) {
1008                        /*
1009                         * If the conditional replenishment algorithm
1010                         * has decided to send any of the blocks of
1011                         * this macroblock, code it.
1012                         */
1013                        u_int s = crvec[blkno];
1014
1015                        if ((s & CR_SEND) != 0) {
1016                                u_int mbpred = mba_;
1017                                encode_mb(mba, frm, loff, coff, CR_STATE(s));
1018                                u_int cbits = ((bc_ - bs_) << 3) + nbb_;
1019                                if (cbits > ec) {
1020                                        pktbuf* npb;
1021                                        npb = pool_->alloc(vf->ts_, RTP_PT_H261);
1022                                        cc += flush(pb, nbit, npb);
1023                                        cbits -= nbit;
1024                                        pb = npb;
1025                                        /* RTP/H.261 header */
1026                                        u_int m = mbpred;
1027                                        u_int g;
1028                                        if (m != 0) {
1029                                                g = gob + 1;
1030                                                m -= 1;
1031                                        } else
1032                                                g = 0;
1033
1034                                        rh = (rtphdr*)pb->data;
1035                                        *(u_int*)(rh + 1) =
1036                                                1 << 25 |
1037                                                m << 15 |
1038                                                g << 20 |
1039                                                mquant_ << 10;
1040                                }
1041                                nbit = cbits;
1042                        }
1043
1044                        loff += loffsize_;
1045                        coff += coffsize_;
1046                        blkno += bloffsize_;
1047                        if (--line <= 0) {
1048                                line = 11;
1049                                blkno += bstride_;
1050                                loff += lstride_;
1051                                coff += cstride_;
1052                        }
1053
1054                }
1055        }
1056        pb->tag = false;
1057        cc += flush(pb, ((bc_ - bs_) << 3) + nbb_, 0);
1058
1059        // time measurement
1060        enc_end_ = get_now();
1061        fprintf(stderr,"\n>>>h261_encode_end\tnow: %f\n", enc_end_);
1062
1063        return (cc);
1064}
1065
1066/*
1067 * average number of packets per frame
1068 */
1069int H261Encoder::avg_packets_per_frame() {
1070        int num = 0;
1071        int k = (vfno_ < FHSIZE) ? vfno_ : FHSIZE;
1072        if (k < 1) return 1;
1073
1074        for (int i = 0; i < k; i++)
1075                num += ppframe_[vfno_%FHSIZE];
1076
1077        return (num /= k);
1078}
1079
1080/*
1081 * if Tx queue is building up more than 5 frames, roughly,
1082 * then we should suspend grabbing to prevent it from growing up forever.
1083 */
1084bool H261Encoder::suspend_grabbing(int m) {
1085        // Tx queue len (in packets) at the time of calling this method
1086        int txq = tx_->tx_buf_size();
1087        // highest watermark
1088        int highmark = 0;
1089
1090        if (vfno_ < FHSIZE)
1091        return false;
1092
1093        // now, highmark is set to "m * (num packets per frame)",
1094        // which roughly represents "m" frames.
1095        highmark = m * avg_packets_per_frame();
1096
1097        if (txq > highmark)
1098                return true;
1099
1100        return false;
1101}
Note: See TracBrowser for help on using the browser.