Changeset 2286

Show
Ignore:
Timestamp:
03/13/99 17:02:22 (15 years ago)
Author:
ucacoxh
Message:

- Bug in vanilla encoder with variable frame codecs - it was packing
state + n * sizeof first frame instead of n + sizes of frames. grrr.
- Tidier bit packing in vdvi codec.

Location:
rat/trunk
Files:
2 modified

Legend:

Unmodified
Added
Removed
  • rat/trunk/cc_vanilla.c

    r2273 r2286  
    109109 
    110110        for(i = 1; i < ve->nelem; i++) { 
    111                 size += ve->elem[0]->rep[0]->data_len; 
     111                size += ve->elem[i]->rep[0]->data_len; 
    112112        } 
    113113 
     
    333333                done = cf->mean_per_packet_state_size; 
    334334                while(done < len) { 
    335                         step = codec_peek_frame_size(cid, buf+done, (u_int16)done); 
     335                        step = codec_peek_frame_size(cid, buf+done, (u_int16)(len - done)); 
    336336                        if (step == 0) { 
    337337                                debug_msg("Zero data len for audio unit ?\n"); 
  • rat/trunk/cx_vdvi.c

    r2285 r2286  
    4848 
    4949#ifdef TEST_VDVI 
    50 #define NUM_TESTS 10000 
     50#define NUM_TESTS 100000 
    5151 
    5252#include <stdio.h> 
     
    106106                        assert(src[i] == dst[i]); 
    107107                } 
    108         } 
    109         printf("Tested %d frames\n", n); 
     108                if (0 == (n % 1000)) { 
     109                        printf("."); 
     110                        fflush(stdout); 
     111                } 
     112        } 
     113        printf("\nTested %d frames\n", n); 
    110114        return 1; 
    111115} 
    112116#endif TEST_DVI 
    113117 
    114 /* 
    115 typedef unsigned int  u_int; 
    116 typedef unsigned char u_char; 
    117 */ 
    118118/* Bitstream structure to make life a little easier */ 
    119119 
    120120typedef struct { 
    121         u_char *buf; 
    122         u_char *pos; 
    123         u_int   bits_remain; 
    124         u_int   len; 
     121        u_char *buf;    /* head of bitstream            */ 
     122        u_char *pos;    /* current byte in bitstream    */ 
     123        u_int   remain; /* bits remaining               */ 
     124        u_int   len;    /* length of bitstream in bytes */ 
    125125} bs; 
    126126 
    127127__inline static void 
    128 bs_init(bs *b, char *buf, int bytes) 
    129 { 
    130         b->buf = b->pos = buf; 
    131         b->len = bytes; 
    132         b->bits_remain = 8; 
     128bs_init(bs *b, char *buf, int blen) 
     129{ 
     130        b->buf    = b->pos = buf; 
     131        b->remain = 8; 
     132        b->len    = blen; 
    133133} 
    134134 
    135135__inline static void 
    136 bs_put(bs* b, u_char in, u_int n_in) 
    137 { 
    138         register u_int   br, t; 
    139         u_char *p; 
    140  
    141         p  = b->pos; 
    142         br = b->bits_remain; 
     136bs_put(bs* b, u_char bits, u_int nbits) 
     137{ 
     138        assert(nbits != 0 && nbits <= 8); 
    143139         
    144         assert(n_in <= 8); 
    145  
    146         if (br == 0) { 
    147                 br = 8; 
    148                 p++; 
    149                 *p = 0; 
     140        if (b->remain == 0) { 
     141                b->pos++; 
     142                b->remain = 8; 
     143        } 
     144 
     145        if (nbits > b->remain) { 
     146                u_int over = nbits - b->remain; 
     147                (*b->pos) |= (bits >> over); 
     148                b->pos++; 
     149                b->remain = 8 - over; 
     150                (*b->pos)  = (bits << b->remain); 
     151        } else { 
     152                (*b->pos) |= bits << (b->remain - nbits); 
     153                b->remain -= nbits; 
    150154        } 
    151155         
    152         if (n_in > br) { 
    153                 t = n_in - br; 
    154                 *p |= in >> t; 
    155                 p++; 
    156                 br = 8 - t; 
    157                 *p = in << br; 
     156        assert((u_int)(b->pos - b->buf) <= b->len); 
     157} 
     158 
     159__inline static u_char 
     160bs_get(bs *b, u_int nbits) 
     161{ 
     162        u_char out; 
     163 
     164        if (b->remain == 0) { 
     165                b->pos++; 
     166                b->remain = 8; 
     167        } 
     168 
     169        if (nbits > b->remain) { 
     170                /* Get high bits */ 
     171                out = *b->pos; 
     172                out <<= (8 - b->remain); 
     173                out >>= (8 - nbits); 
     174                b->pos++; 
     175                b->remain += 8 - nbits; 
     176                out |= (*b->pos) >> b->remain; 
    158177        } else { 
    159                 *p |= in << ( br - n_in); 
    160                 br -= n_in; 
    161         } 
    162  
    163         b->pos = p; 
    164         b->bits_remain = br; 
    165         assert(((u_char)(b->pos - b->buf) < b->len) || 
    166                 ((u_char)(b->pos - b->buf) == b->len && b->bits_remain == 8)); 
    167 } 
    168  
    169 __inline static u_char 
    170 bs_get(bs *b, u_int bits) 
    171 { 
    172         register char *p; 
    173         register u_int br; 
    174  
    175         u_char mask,out; 
    176          
    177         p  = b->pos; 
    178         br = b->bits_remain; 
    179  
    180         if (bits >= br) { 
    181                 mask = 0xff >> (8 - br); 
    182                 bits -= br; 
    183                 out = (*p & mask) << bits; 
    184                 p++; 
    185                 br = 8 - bits; 
    186                 mask = 0xff << br; 
    187                 out |= (*p & mask) >> br; 
    188         } else { 
    189                 br -= bits; 
    190                 mask = (0xff >> (8 - bits)); 
    191                 mask <<=  br; 
    192                 out  = (*p & mask) >> br; 
    193         } 
    194         b->pos = p; 
    195         b->bits_remain = br; 
    196         assert(((u_char)(b->pos - b->buf) < b->len) || 
    197                 ((u_char)(b->pos - b->buf) == b->len && b->bits_remain == 8)); 
     178                out = *b->pos; 
     179                out <<= (8 - b->remain); 
     180                out >>= (8 - nbits); 
     181                b->remain -= nbits; 
     182        } 
     183 
     184        assert((u_int)(b->pos - b->buf) <= b->len); 
    198185        return out; 
    199186} 
    200187 
     188static u_int  
     189bs_used(bs *b) 
     190{ 
     191        u_int used = (u_int)(b->pos - b->buf); 
     192        if (b->remain != 8) { 
     193                used++; 
     194        } 
     195        return used; 
     196} 
    201197 
    202198/* VDVI translations as defined in draft-ietf-avt-profile-new-00.txt  
     
    262258        } 
    263259        /* Return number of bytes used */ 
    264         bytes_used  = (dst.pos - dst.buf); 
    265         bytes_used += (dst.bits_remain != 8) ? 1 : 0; 
     260        bytes_used  = bs_used(&dst); 
    266261        assert(bytes_used <= out_bytes); 
    267262        return bytes_used; 
     
    318313        } 
    319314 
    320         bytes_used  = (bin.pos - bin.buf); 
    321         bytes_used += (bin.bits_remain != 8) ? 1 : 0; 
     315        bytes_used = bs_used(&bin); 
    322316 
    323317        assert(bytes_used <= in_bytes);