make some functions static (patch by Dieter < freebsd at sopwith.solgatos.com >)
[libav.git] / libavcodec / h261.c
index 490e0d3..c6218c8 100644 (file)
@@ -15,7 +15,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /**
@@ -53,8 +53,6 @@ typedef struct H261Context{
     int current_mv_x;
     int current_mv_y;
     int gob_number;
-    int bits_left; //8 - nr of bits left of the following frame in the last byte in this frame
-    int last_bits; //bits left of the following frame in the last byte in this frame
     int gob_start_code_skipped; // 1 if gob start code is already read before gob header is read
 }H261Context;
 
@@ -105,22 +103,22 @@ void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
 
     put_bits(&s->pb, 20, 0x10); /* PSC */
 
-    temp_ref= s->picture_number * (int64_t)30000 * s->avctx->frame_rate_base / 
-                         (1001 * (int64_t)s->avctx->frame_rate);
+    temp_ref= s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
+                         (1001 * (int64_t)s->avctx->time_base.den); //FIXME maybe this should use a timestamp
     put_bits(&s->pb, 5, temp_ref & 0x1f); /* TemporalReference */
 
     put_bits(&s->pb, 1, 0); /* split screen off */
     put_bits(&s->pb, 1, 0); /* camera  off */
     put_bits(&s->pb, 1, 0); /* freeze picture release off */
-    
+
     format = ff_h261_get_picture_format(s->width, s->height);
-    
+
     put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
 
     put_bits(&s->pb, 1, 0); /* still image mode */
     put_bits(&s->pb, 1, 0); /* reserved */
 
-    put_bits(&s->pb, 1, 0); /* no PEI */    
+    put_bits(&s->pb, 1, 0); /* no PEI */
     if(format == 0)
         h->gob_number = -1;
     else
@@ -150,38 +148,21 @@ static void h261_encode_gob_header(MpegEncContext * s, int mb_line){
 }
 
 void ff_h261_reorder_mb_index(MpegEncContext* s){
+    int index= s->mb_x + s->mb_y*s->mb_width;
+
+    if(index % 33 == 0)
+        h261_encode_gob_header(s,0);
+
     /* for CIF the GOB's are fragmented in the middle of a scanline
        that's why we need to adjust the x and y index of the macroblocks */
     if(ff_h261_get_picture_format(s->width,s->height) == 1){ // CIF
-        if((s->mb_x == 0 && (s->mb_y % 3 == 0) ) || (s->mb_x == 11 && ((s->mb_y -1 )% 3 == 0) ))
-            h261_encode_gob_header(s,0);
-        if(s->mb_x < 11 ){
-            if((s->mb_y % 3) == 1 ){
-                s->mb_x += 0;
-                s->mb_y += 1;
-            }
-            else if( (s->mb_y % 3) == 2 ){
-                s->mb_x += 11;
-                s->mb_y -= 1;
-            }
-        }
-        else{
-            if((s->mb_y % 3) == 1 ){
-                s->mb_x += 0;
-                s->mb_y -= 1;
-            }
-            else if( (s->mb_y % 3) == 0 ){
-                s->mb_x -= 11;
-                s->mb_y += 1;
-            }
-        }
+        s->mb_x =     index % 11 ; index /= 11;
+        s->mb_y =     index %  3 ; index /=  3;
+        s->mb_x+= 11*(index %  2); index /=  2;
+        s->mb_y+=  3*index;
+
         ff_init_block_index(s);
         ff_update_block_index(s);
-    /* for QCIF we don't need to reorder MB's
-       there the GOB's aren't fragmented in the middle of a scanline */
-    }else if(ff_h261_get_picture_format(s->width,s->height) == 0){ // QCIF
-        if(s->mb_y % 3 == 0 && s->mb_x == 0)
-            h261_encode_gob_header(s,0);
     }
 }
 
@@ -191,14 +172,14 @@ static void h261_encode_motion(H261Context * h, int val){
     if(val==0){
         code = 0;
         put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
-    } 
+    }
     else{
-        if(val > 16)
+        if(val > 15)
             val -=32;
         if(val < -16)
             val+=32;
         sign = val < 0;
-        code = sign ? -val : val; 
+        code = sign ? -val : val;
         put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
         put_bits(&s->pb,1,sign);
     }
@@ -220,27 +201,20 @@ void ff_h261_encode_mb(MpegEncContext * s,
          int motion_x, int motion_y)
 {
     H261Context * h = (H261Context *)s;
-    int old_mtype, mvd, mv_diff_x, mv_diff_y, i, cbp;
+    int mvd, mv_diff_x, mv_diff_y, i, cbp;
     cbp = 63; // avoid warning
     mvd = 0;
+
     h->current_mba++;
-    old_mtype = h->mtype;
     h->mtype = 0;
+
     if (!s->mb_intra){
         /* compute cbp */
         cbp= get_cbp(s, block);
-   
+
         /* mvd indicates if this block is motion compensated */
-        if(((motion_x >> 1) - h->current_mv_x != 0) || ((motion_y >> 1 ) - h->current_mv_y) != 0){
-            mvd = 1;
-        }
-        else if((motion_x >> 1 == 0) && (motion_y >> 1 == 0)){
-            mvd = 0;
-        }
-        else
-            mvd = 1;
+        mvd = motion_x | motion_y;
+
         if((cbp | mvd | s->dquant ) == 0) {
             /* skip macroblock */
             s->skip_count++;
@@ -252,31 +226,32 @@ void ff_h261_encode_mb(MpegEncContext * s,
 
     /* MB is not skipped, encode MBA */
     put_bits(&s->pb, h261_mba_bits[(h->current_mba-h->previous_mba)-1], h261_mba_code[(h->current_mba-h->previous_mba)-1]);
+
     /* calculate MTYPE */
     if(!s->mb_intra){
-        h->mtype+=2;
-    if(mvd == 1){   
-        h->mtype+=2;
-        if(cbp!=0)
-            h->mtype+=1;
+        h->mtype++;
+
+        if(mvd || s->loop_filter)
+            h->mtype+=3;
         if(s->loop_filter)
             h->mtype+=3;
-        }
+        if(cbp || s->dquant)
+            h->mtype++;
+        assert(h->mtype > 1);
     }
 
-    if(s->dquant) 
+    if(s->dquant)
         h->mtype++;
 
     put_bits(&s->pb, h261_mtype_bits[h->mtype], h261_mtype_code[h->mtype]);
+
     h->mtype = h261_mtype_map[h->mtype];
+
     if(IS_QUANT(h->mtype)){
         ff_set_qscale(s,s->qscale+s->dquant);
         put_bits(&s->pb, 5, s->qscale);
     }
+
     if(IS_16X16(h->mtype)){
         mv_diff_x = (motion_x >> 1) - h->current_mv_x;
         mv_diff_y = (motion_y >> 1) - h->current_mv_y;
@@ -285,11 +260,11 @@ void ff_h261_encode_mb(MpegEncContext * s,
         h261_encode_motion(h,mv_diff_x);
         h261_encode_motion(h,mv_diff_y);
     }
+
     h->previous_mba = h->current_mba;
+
     if(HAS_CBP(h->mtype)){
-        put_bits(&s->pb,h261_cbp_tab[cbp-1][1],h261_cbp_tab[cbp-1][0]); 
+        put_bits(&s->pb,h261_cbp_tab[cbp-1][1],h261_cbp_tab[cbp-1][0]);
     }
     for(i=0; i<6; i++) {
         /* encode each block */
@@ -304,10 +279,10 @@ void ff_h261_encode_mb(MpegEncContext * s,
 
 void ff_h261_encode_init(MpegEncContext *s){
     static int done = 0;
-    
+
     if (!done) {
         done = 1;
-        init_rl(&h261_rl_tcoeff);
+        init_rl(&h261_rl_tcoeff, 1);
     }
 
     s->min_qcoeff= -127;
@@ -348,13 +323,12 @@ static void h261_encode_block(H261Context * h, DCTELEM * block, int n){
         i = 1;
     } else if((block[0]==1 || block[0] == -1) && (s->block_last_index[n] > -1)){
         //special case
-        put_bits(&s->pb,1,1);
-        put_bits(&s->pb,1,block[0]>0 ? 0 : 1 );
+        put_bits(&s->pb,2,block[0]>0 ? 2 : 3 );
         i = 1;
     } else {
         i = 0;
     }
-   
+
     /* AC coefs */
     last_index = s->block_last_index[n];
     last_non_zero = i - 1;
@@ -377,12 +351,7 @@ static void h261_encode_block(H261Context * h, DCTELEM * block, int n){
             if (code == rl->n) {
                 put_bits(&s->pb, 6, run);
                 assert(slevel != 0);
-                if(slevel < -127){
-                    slevel = -127;
-                }
-                else if(slevel > 127){
-                    slevel = 127;
-                }
+                assert(level <= 127);
                 put_bits(&s->pb, 8, slevel & 0xff);
             } else {
                 put_bits(&s->pb, 1, sign);
@@ -403,7 +372,7 @@ static VLC h261_mtype_vlc;
 static VLC h261_mv_vlc;
 static VLC h261_cbp_vlc;
 
-void init_vlc_rl(RLTable *rl);
+void init_vlc_rl(RLTable *rl, int use_static);
 
 static void h261_decode_init_vlc(H261Context *h){
     static int done = 0;
@@ -412,18 +381,18 @@ static void h261_decode_init_vlc(H261Context *h){
         done = 1;
         init_vlc(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
                  h261_mba_bits, 1, 1,
-                 h261_mba_code, 1, 1);
+                 h261_mba_code, 1, 1, 1);
         init_vlc(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
                  h261_mtype_bits, 1, 1,
-                 h261_mtype_code, 1, 1);
+                 h261_mtype_code, 1, 1, 1);
         init_vlc(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
                  &h261_mv_tab[0][1], 2, 1,
-                 &h261_mv_tab[0][0], 2, 1);
+                 &h261_mv_tab[0][0], 2, 1, 1);
         init_vlc(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
                  &h261_cbp_tab[0][1], 2, 1,
-                 &h261_cbp_tab[0][0], 2, 1);
-        init_rl(&h261_rl_tcoeff);
-        init_vlc_rl(&h261_rl_tcoeff);
+                 &h261_cbp_tab[0][0], 2, 1, 1);
+        init_rl(&h261_rl_tcoeff, 1);
+        init_vlc_rl(&h261_rl_tcoeff, 1);
     }
 }
 
@@ -448,7 +417,7 @@ static int h261_decode_init(AVCodecContext *avctx){
     h261_decode_init_vlc(h);
 
     h->gob_start_code_skipped = 0;
-    
+
     return 0;
 }
 
@@ -459,7 +428,7 @@ static int h261_decode_init(AVCodecContext *avctx){
 static int h261_decode_gob_header(H261Context *h){
     unsigned int val;
     MpegEncContext * const s = &h->s;
-    
+
     if ( !h->gob_start_code_skipped ){
         /* Check for GOB Start Code */
         val = show_bits(&s->gb, 15);
@@ -551,7 +520,7 @@ static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
 {
     MpegEncContext * const s = &h->s;
     int i;
-    
+
     s->mb_intra = 0;
 
     for(i=mba1; i<mba2; i++){
@@ -562,7 +531,6 @@ static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
         xy = s->mb_x + s->mb_y * s->mb_stride;
         ff_init_block_index(s);
         ff_update_block_index(s);
-        s->dsp.clear_blocks(s->block[0]);
 
         for(j=0;j<6;j++)
             s->block_last_index[j] = -1;
@@ -572,7 +540,7 @@ static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
         s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
         s->mv[0][0][0] = 0;
         s->mv[0][0][1] = 0;
-        s->mb_skiped = 1;
+        s->mb_skipped = 1;
         h->mtype &= ~MB_TYPE_H261_FIL;
 
         MPV_decode_mb(s, s->block);
@@ -592,7 +560,7 @@ static int decode_mv_component(GetBitContext *gb, int v){
 
     if(mv_diff && !get_bits1(gb))
         mv_diff= -mv_diff;
-    
+
     v += mv_diff;
     if     (v <=-16) v+= 32;
     else if(v >= 16) v-= 32;
@@ -602,7 +570,7 @@ static int decode_mv_component(GetBitContext *gb, int v){
 
 static int h261_decode_mb(H261Context *h){
     MpegEncContext * const s = &h->s;
-    int i, cbp, xy, old_mtype;
+    int i, cbp, xy;
 
     cbp = 63;
     // Read mba
@@ -631,16 +599,14 @@ static int h261_decode_mb(H261Context *h){
 
     if ( h->current_mba > MBA_STUFFING )
         return SLICE_ERROR;
-    
+
     s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
     s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
     xy = s->mb_x + s->mb_y * s->mb_stride;
     ff_init_block_index(s);
     ff_update_block_index(s);
-    s->dsp.clear_blocks(s->block[0]);
 
     // Read mtype
-    old_mtype = h->mtype;
     h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
     h->mtype = h261_mtype_map[h->mtype];
 
@@ -660,7 +626,7 @@ static int h261_decode_mb(H261Context *h){
         // 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
         // 3) MTYPE of the previous macroblock was not MC.
         if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
-             ( h->mba_diff != 1) || ( !IS_16X16 ( old_mtype ) ))
+             ( h->mba_diff != 1))
         {
             h->current_mv_x = 0;
             h->current_mv_y = 0;
@@ -668,6 +634,9 @@ static int h261_decode_mb(H261Context *h){
 
         h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x);
         h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y);
+    }else{
+        h->current_mv_x = 0;
+        h->current_mv_y = 0;
     }
 
     // Read cbp
@@ -684,24 +653,22 @@ static int h261_decode_mb(H261Context *h){
     s->mv_dir = MV_DIR_FORWARD;
     s->mv_type = MV_TYPE_16X16;
     s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0;
-    if(IS_16X16 ( h->mtype )){
-        s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation
-        s->mv[0][0][1] = h->current_mv_y * 2;
-    }
-    else{
-        h->current_mv_x = s->mv[0][0][0] = 0;
-        h->current_mv_x = s->mv[0][0][1] = 0;
-    }
+    s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation
+    s->mv[0][0][1] = h->current_mv_y * 2;
 
 intra:
     /* decode each block */
     if(s->mb_intra || HAS_CBP(h->mtype)){
+        s->dsp.clear_blocks(s->block[0]);
         for (i = 0; i < 6; i++) {
             if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
                 return SLICE_ERROR;
             }
             cbp+=cbp;
         }
+    }else{
+        for (i = 0; i < 6; i++)
+            s->block_last_index[i]= -1;
     }
 
     MPV_decode_mb(s, s->block);
@@ -720,7 +687,7 @@ static int h261_decode_block(H261Context * h, DCTELEM * block,
     int code, level, i, j, run;
     RLTable *rl = &h261_rl_tcoeff;
     const uint8_t *scan_table;
-    
+
     // For the variable length encoding there are two code tables, one being used for
     // the first transmitted LEVEL in INTER, INTER+MC and INTER+MC+FIL blocks, the second
     // for all other LEVELs except the first one in INTRA blocks which is fixed length
@@ -769,7 +736,7 @@ static int h261_decode_block(H261Context * h, DCTELEM * block,
             /* escape */
             // The remaining combinations of (run, level) are encoded with a 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits level.
             run = get_bits(&s->gb, 6);
-            level = (int8_t)get_bits(&s->gb, 8);
+            level = get_sbits(&s->gb, 8);
         }else if(code == 0){
             break;
         }else{
@@ -795,7 +762,7 @@ static int h261_decode_block(H261Context * h, DCTELEM * block,
  * decodes the H261 picture header.
  * @return <0 if no startcode found
  */
-int h261_decode_picture_header(H261Context *h){
+static int h261_decode_picture_header(H261Context *h){
     MpegEncContext * const s = &h->s;
     int format, i;
     uint32_t startcode= 0;
@@ -845,7 +812,7 @@ int h261_decode_picture_header(H261Context *h){
         skip_bits(&s->gb, 8);
     }
 
-    // h261 has no I-FRAMES, but if we pass I_TYPE for the first frame, the codec crashes if it does 
+    // h261 has no I-FRAMES, but if we pass I_TYPE for the first frame, the codec crashes if it does
     // not contain all I-blocks (e.g. when a packet is lost)
     s->pict_type = P_TYPE;
 
@@ -855,7 +822,7 @@ int h261_decode_picture_header(H261Context *h){
 
 static int h261_decode_gob(H261Context *h){
     MpegEncContext * const s = &h->s;
-    
+
     ff_set_qscale(s, s->qscale);
 
     /* decode mb's */
@@ -866,62 +833,44 @@ static int h261_decode_gob(H261Context *h){
         ret= h261_decode_mb(h);
         if(ret<0){
             if(ret==SLICE_END){
-                h261_decode_mb_skipped(h, h->current_mba, 33);                
+                h261_decode_mb_skipped(h, h->current_mba, 33);
                 return 0;
             }
             av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
             return -1;
         }
-        
+
         h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1);
     }
-    
+
     return -1;
 }
 
 static int h261_find_frame_end(ParseContext *pc, AVCodecContext* avctx, const uint8_t *buf, int buf_size){
-    int vop_found, i, j, bits_left, last_bits;
+    int vop_found, i, j;
     uint32_t state;
 
-    H261Context *h = avctx->priv_data;
-
-    if(h){
-        bits_left = h->bits_left;
-        last_bits = h->last_bits;
-    }
-    else{
-        bits_left = 0;
-        last_bits = 0;
-    }
-
     vop_found= pc->frame_start_found;
     state= pc->state;
-    if(bits_left!=0 && !vop_found)
-        state = state << (8-bits_left) | last_bits;
-    i=0;
-    if(!vop_found){
-        for(i=0; i<buf_size; i++){
-            state= (state<<8) | buf[i];
-            for(j=0; j<8; j++){
-                if(( (  (state<<j)  |  (buf[i]>>(8-j))  )>>(32-20) == 0x10 )&&(((state >> (17-j)) & 0x4000) == 0x0)){
-                    i++;
-                    vop_found=1;
-                    break;
-                }
+
+    for(i=0; i<buf_size && !vop_found; i++){
+        state= (state<<8) | buf[i];
+        for(j=0; j<8; j++){
+            if(((state>>j)&0xFFFFF) == 0x00010){
+                i++;
+                vop_found=1;
+                break;
             }
-            if(vop_found)
-                    break;    
         }
     }
     if(vop_found){
         for(; i<buf_size; i++){
-            if(avctx->flags & CODEC_FLAG_TRUNCATED)//XXX ffplay workaround, someone a better solution?
-                state= (state<<8) | buf[i];
+            state= (state<<8) | buf[i];
             for(j=0; j<8; j++){
-                if(( (  (state<<j)  |  (buf[i]>>(8-j))  )>>(32-20) == 0x10 )&&(((state >> (17-j)) & 0x4000) == 0x0)){
+                if(((state>>j)&0xFFFFF) == 0x00010){
                     pc->frame_start_found=0;
-                    pc->state=-1;
-                    return i-3;
+                    pc->state= state>>(2*8);
+                    return i-1;
                 }
             }
         }
@@ -934,12 +883,12 @@ static int h261_find_frame_end(ParseContext *pc, AVCodecContext* avctx, const ui
 
 static int h261_parse(AVCodecParserContext *s,
                       AVCodecContext *avctx,
-                      uint8_t **poutbuf, int *poutbuf_size, 
+                      uint8_t **poutbuf, int *poutbuf_size,
                       const uint8_t *buf, int buf_size)
 {
     ParseContext *pc = s->priv_data;
     int next;
-    
+
     next= h261_find_frame_end(pc,avctx, buf, buf_size);
     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
         *poutbuf = NULL;
@@ -955,18 +904,11 @@ static int h261_parse(AVCodecParserContext *s,
  * returns the number of bytes consumed for building the current frame
  */
 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
-    if(s->flags&CODEC_FLAG_TRUNCATED){
-        int pos= (get_bits_count(&s->gb)+7)>>3;
-        pos -= s->parse_context.last_index;
-        if(pos<0) pos=0;// padding is not really read so this might be -1
-        return pos;
-    }else{
-        int pos= get_bits_count(&s->gb)>>3;
-        if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
-        if(pos+10>buf_size) pos=buf_size; // oops ;)
+    int pos= get_bits_count(&s->gb)>>3;
+    if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
+    if(pos+10>buf_size) pos=buf_size; // oops ;)
 
-        return pos;
-    }
+    return pos;
 }
 
 static int h261_decode_frame(AVCodecContext *avctx,
@@ -985,20 +927,7 @@ static int h261_decode_frame(AVCodecContext *avctx,
     s->flags= avctx->flags;
     s->flags2= avctx->flags2;
 
-    /* no supplementary picture */
-    if (buf_size == 0) {
-        return 0;
-    }
-
-    if(s->flags&CODEC_FLAG_TRUNCATED){
-        int next;
-
-        next= h261_find_frame_end(&s->parse_context,avctx, buf, buf_size);
-
-        if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 )
-            return buf_size;
-    }
-
+    h->gob_start_code_skipped=0;
 
 retry:
 
@@ -1041,6 +970,10 @@ retry:
 
     /* skip everything if we are in a hurry>=5 */
     if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);
+    if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
+       ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
+       || avctx->skip_frame >= AVDISCARD_ALL)
+        return get_consumed_bytes(s, buf_size);
 
     if(MPV_frame_start(s, avctx) < 0)
         return -1;
@@ -1060,7 +993,7 @@ retry:
 
 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
 assert(s->current_picture.pict_type == s->pict_type);
-    *pict= *(AVFrame*)&s->current_picture;
+    *pict= *(AVFrame*)s->current_picture_ptr;
     ff_print_debug_info(s, pict);
 
     /* Return the Picture timestamp as the frame number */
@@ -1081,6 +1014,7 @@ static int h261_decode_end(AVCodecContext *avctx)
     return 0;
 }
 
+#ifdef CONFIG_ENCODERS
 AVCodec h261_encoder = {
     "h261",
     CODEC_TYPE_VIDEO,
@@ -1090,6 +1024,7 @@ AVCodec h261_encoder = {
     MPV_encode_picture,
     MPV_encode_end,
 };
+#endif
 
 AVCodec h261_decoder = {
     "h261",
@@ -1100,7 +1035,7 @@ AVCodec h261_decoder = {
     NULL,
     h261_decode_end,
     h261_decode_frame,
-    CODEC_CAP_TRUNCATED,
+    CODEC_CAP_DR1,
 };
 
 AVCodecParser h261_parser = {