Merge commit '835f798c7d20bca89eb4f3593846251ad0d84e4b'
[ffmpeg.git] / libavcodec / h261dec.c
index 47c3032..301ecc1 100644 (file)
 
 #include "libavutil/avassert.h"
 #include "avcodec.h"
+#include "mpeg_er.h"
+#include "mpegutils.h"
 #include "mpegvideo.h"
 #include "h263.h"
 #include "h261.h"
-#include "h261data.h"
+#include "internal.h"
 
 #define H261_MBA_VLC_BITS 9
 #define H261_MTYPE_VLC_BITS 6
@@ -45,8 +47,6 @@ static VLC h261_mtype_vlc;
 static VLC h261_mv_vlc;
 static VLC h261_cbp_vlc;
 
-static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded);
-
 static av_cold void h261_decode_init_vlc(H261Context *h)
 {
     static int done = 0;
@@ -65,7 +65,6 @@ static av_cold void h261_decode_init_vlc(H261Context *h)
         INIT_VLC_STATIC(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
                         &ff_h261_cbp_tab[0][1], 2, 1,
                         &ff_h261_cbp_tab[0][0], 2, 1, 512);
-        ff_init_rl(&ff_h261_rl_tcoeff, ff_h261_rl_table_store);
         INIT_VLC_RL(ff_h261_rl_tcoeff, 552);
     }
 }
@@ -76,7 +75,7 @@ static av_cold int h261_decode_init(AVCodecContext *avctx)
     MpegEncContext *const s = &h->s;
 
     // set defaults
-    ff_MPV_decode_defaults(s);
+    ff_mpv_decode_defaults(s);
     s->avctx       = avctx;
     s->width       = s->avctx->coded_width;
     s->height      = s->avctx->coded_height;
@@ -86,6 +85,7 @@ static av_cold int h261_decode_init(AVCodecContext *avctx)
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
     s->codec_id    = avctx->codec->id;
 
+    ff_h261_common_init();
     h261_decode_init_vlc(h);
 
     h->gob_start_code_skipped = 0;
@@ -128,8 +128,8 @@ static int h261_decode_gob_header(H261Context *h)
     }
 
     /* GEI */
-    while (get_bits1(&s->gb) != 0)
-        skip_bits(&s->gb, 8);
+    if (skip_1stop_8data_bits(&s->gb) < 0)
+        return AVERROR_INVALIDDATA;
 
     if (s->qscale == 0) {
         av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
@@ -151,7 +151,7 @@ static int h261_decode_gob_header(H261Context *h)
  * Decode the group of blocks / video packet header.
  * @return <0 if no resync found
  */
-static int ff_h261_resync(H261Context *h)
+static int h261_resync(H261Context *h)
 {
     MpegEncContext *const s = &h->s;
     int left, ret;
@@ -219,17 +219,18 @@ static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2)
         s->mb_skipped                  = 1;
         h->mtype                      &= ~MB_TYPE_H261_FIL;
 
-        ff_MPV_decode_mb(s, s->block);
+        ff_mpv_decode_mb(s, s->block);
     }
 
     return 0;
 }
 
+static const int mvmap[17] = {
+    0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16
+};
+
 static int decode_mv_component(GetBitContext *gb, int v)
 {
-    static const int mvmap[17] = {
-        0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16
-    };
     int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2);
 
     /* check if mv_diff is valid */
@@ -250,6 +251,94 @@ static int decode_mv_component(GetBitContext *gb, int v)
     return v;
 }
 
+/**
+ * Decode a macroblock.
+ * @return <0 if an error occurred
+ */
+static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded)
+{
+    MpegEncContext *const s = &h->s;
+    int code, level, i, j, run;
+    RLTable *rl = &ff_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 coded with 8 bits.
+     * NOTE: The two code tables only differ in one VLC so we handle that
+     * manually. */
+    scan_table = s->intra_scantable.permutated;
+    if (s->mb_intra) {
+        /* DC coef */
+        level = get_bits(&s->gb, 8);
+        // 0 (00000000b) and -128 (10000000b) are FORBIDDEN
+        if ((level & 0x7F) == 0) {
+            av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n",
+                   level, s->mb_x, s->mb_y);
+            return -1;
+        }
+        /* The code 1000 0000 is not used, the reconstruction level of 1024
+         * being coded as 1111 1111. */
+        if (level == 255)
+            level = 128;
+        block[0] = level;
+        i        = 1;
+    } else if (coded) {
+        // Run  Level   Code
+        // EOB          Not possible for first level when cbp is available (that's why the table is different)
+        // 0    1       1s
+        // *    *       0*
+        int check = show_bits(&s->gb, 2);
+        i = 0;
+        if (check & 0x2) {
+            skip_bits(&s->gb, 2);
+            block[0] = (check & 0x1) ? -1 : 1;
+            i        = 1;
+        }
+    } else {
+        i = 0;
+    }
+    if (!coded) {
+        s->block_last_index[n] = i - 1;
+        return 0;
+    }
+    for (;;) {
+        code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
+        if (code < 0) {
+            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n",
+                   s->mb_x, s->mb_y);
+            return -1;
+        }
+        if (code == rl->n) {
+            /* 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 = get_sbits(&s->gb, 8);
+        } else if (code == 0) {
+            break;
+        } else {
+            run   = rl->table_run[code];
+            level = rl->table_level[code];
+            if (get_bits1(&s->gb))
+                level = -level;
+        }
+        i += run;
+        if (i >= 64) {
+            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n",
+                   s->mb_x, s->mb_y);
+            return -1;
+        }
+        j        = scan_table[i];
+        block[j] = level;
+        i++;
+    }
+    s->block_last_index[n] = i - 1;
+    return 0;
+}
+
 static int h261_decode_mb(H261Context *h)
 {
     MpegEncContext *const s = &h->s;
@@ -292,9 +381,11 @@ static int h261_decode_mb(H261Context *h)
     // Read mtype
     h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
     if (h->mtype < 0) {
-        av_log(s->avctx, AV_LOG_ERROR, "illegal mtype %d\n", h->mtype);
+        av_log(s->avctx, AV_LOG_ERROR, "Invalid mtype index %d\n",
+               h->mtype);
         return SLICE_ERROR;
     }
+    av_assert0(h->mtype < FF_ARRAY_ELEMS(ff_h261_mtype_map));
     h->mtype = ff_h261_mtype_map[h->mtype];
 
     // Read mquant
@@ -342,10 +433,17 @@ static int h261_decode_mb(H261Context *h)
     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;
 
+    if (s->current_picture.motion_val[0]) {
+        int b_stride = 2*s->mb_width + 1;
+        int b_xy     = 2 * s->mb_x + (2 * s->mb_y) * b_stride;
+        s->current_picture.motion_val[0][b_xy][0] = s->mv[0][0][0];
+        s->current_picture.motion_val[0][b_xy][1] = s->mv[0][0][1];
+    }
+
 intra:
     /* decode each block */
     if (s->mb_intra || HAS_CBP(h->mtype)) {
-        s->dsp.clear_blocks(s->block[0]);
+        s->bdsp.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;
@@ -356,99 +454,11 @@ intra:
             s->block_last_index[i] = -1;
     }
 
-    ff_MPV_decode_mb(s, s->block);
+    ff_mpv_decode_mb(s, s->block);
 
     return SLICE_OK;
 }
 
-/**
- * Decode a macroblock.
- * @return <0 if an error occurred
- */
-static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded)
-{
-    MpegEncContext *const s = &h->s;
-    int code, level, i, j, run;
-    RLTable *rl = &ff_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 coded with 8 bits.
-     * NOTE: The two code tables only differ in one VLC so we handle that
-     * manually. */
-    scan_table = s->intra_scantable.permutated;
-    if (s->mb_intra) {
-        /* DC coef */
-        level = get_bits(&s->gb, 8);
-        // 0 (00000000b) and -128 (10000000b) are FORBIDDEN
-        if ((level & 0x7F) == 0) {
-            av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n",
-                   level, s->mb_x, s->mb_y);
-            return -1;
-        }
-        /* The code 1000 0000 is not used, the reconstruction level of 1024
-         * being coded as 1111 1111. */
-        if (level == 255)
-            level = 128;
-        block[0] = level;
-        i        = 1;
-    } else if (coded) {
-        // Run  Level   Code
-        // EOB          Not possible for first level when cbp is available (that's why the table is different)
-        // 0    1       1s
-        // *    *       0*
-        int check = show_bits(&s->gb, 2);
-        i = 0;
-        if (check & 0x2) {
-            skip_bits(&s->gb, 2);
-            block[0] = (check & 0x1) ? -1 : 1;
-            i        = 1;
-        }
-    } else {
-        i = 0;
-    }
-    if (!coded) {
-        s->block_last_index[n] = i - 1;
-        return 0;
-    }
-    for (;;) {
-        code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
-        if (code < 0) {
-            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n",
-                   s->mb_x, s->mb_y);
-            return -1;
-        }
-        if (code == rl->n) {
-            /* 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 = get_sbits(&s->gb, 8);
-        } else if (code == 0) {
-            break;
-        } else {
-            run   = rl->table_run[code];
-            level = rl->table_level[code];
-            if (get_bits1(&s->gb))
-                level = -level;
-        }
-        i += run;
-        if (i >= 64) {
-            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n",
-                   s->mb_x, s->mb_y);
-            return -1;
-        }
-        j        = scan_table[i];
-        block[j] = level;
-        i++;
-    }
-    s->block_last_index[n] = i - 1;
-    return 0;
-}
-
 /**
  * Decode the H.261 picture header.
  * @return <0 if no startcode found
@@ -478,7 +488,6 @@ static int h261_decode_picture_header(H261Context *h)
     s->picture_number = (s->picture_number & ~31) + i;
 
     s->avctx->time_base      = (AVRational) { 1001, 30000 };
-    s->current_picture.f.pts = s->picture_number;
 
     /* PTYPE starts here */
     skip_bits1(&s->gb); /* split screen off */
@@ -506,8 +515,8 @@ static int h261_decode_picture_header(H261Context *h)
     skip_bits1(&s->gb); /* Reserved */
 
     /* PEI */
-    while (get_bits1(&s->gb) != 0)
-        skip_bits(&s->gb, 8);
+    if (skip_1stop_8data_bits(&s->gb) < 0)
+        return AVERROR_INVALIDDATA;
 
     /* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
      * frame, the codec crashes if it does not contain all I-blocks
@@ -583,17 +592,7 @@ retry:
 
     if (!s->context_initialized)
         // we need the IDCT permutaton for reading a custom matrix
-        if (ff_MPV_common_init(s) < 0)
-            return -1;
-
-    /* We need to set current_picture_ptr before reading the header,
-     * otherwise we cannot store anything in there. */
-    if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
-        int i = ff_find_unused_picture(s, 0);
-        if (i < 0)
-            return i;
-        s->current_picture_ptr = &s->picture[i];
-    }
+        ff_mpv_idct_init(s);
 
     ret = h261_decode_picture_header(h);
 
@@ -606,25 +605,31 @@ retry:
     if (s->width != avctx->coded_width || s->height != avctx->coded_height) {
         ParseContext pc = s->parse_context; // FIXME move this demuxing hack to libavformat
         s->parse_context.buffer = 0;
-        ff_MPV_common_end(s);
+        ff_mpv_common_end(s);
         s->parse_context = pc;
     }
+
     if (!s->context_initialized) {
-        avcodec_set_dimensions(avctx, s->width, s->height);
+        if ((ret = ff_mpv_common_init(s)) < 0)
+            return ret;
+
+        ret = ff_set_dimensions(avctx, s->width, s->height);
+        if (ret < 0)
+            return ret;
 
         goto retry;
     }
 
     // for skipping the frame
-    s->current_picture.f.pict_type = s->pict_type;
-    s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
+    s->current_picture.f->pict_type = s->pict_type;
+    s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
 
     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
          avctx->skip_frame >= AVDISCARD_ALL)
         return get_consumed_bytes(s, buf_size);
 
-    if (ff_MPV_frame_start(s, avctx) < 0)
+    if (ff_mpv_frame_start(s, avctx) < 0)
         return -1;
 
     ff_mpeg_er_frame_start(s);
@@ -634,16 +639,16 @@ retry:
     s->mb_y = 0;
 
     while (h->gob_number < (s->mb_height == 18 ? 12 : 5)) {
-        if (ff_h261_resync(h) < 0)
+        if (h261_resync(h) < 0)
             break;
         h261_decode_gob(h);
     }
-    ff_MPV_frame_end(s);
+    ff_mpv_frame_end(s);
 
-    av_assert0(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
-    av_assert0(s->current_picture.f.pict_type == s->pict_type);
+    av_assert0(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
+    av_assert0(s->current_picture.f->pict_type == s->pict_type);
 
-    if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
+    if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
         return ret;
     ff_print_debug_info(s, s->current_picture_ptr, pict);
 
@@ -657,12 +662,13 @@ static av_cold int h261_decode_end(AVCodecContext *avctx)
     H261Context *h    = avctx->priv_data;
     MpegEncContext *s = &h->s;
 
-    ff_MPV_common_end(s);
+    ff_mpv_common_end(s);
     return 0;
 }
 
 AVCodec ff_h261_decoder = {
     .name           = "h261",
+    .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H261,
     .priv_data_size = sizeof(H261Context),
@@ -671,5 +677,4 @@ AVCodec ff_h261_decoder = {
     .decode         = h261_decode_frame,
     .capabilities   = CODEC_CAP_DR1,
     .max_lowres     = 3,
-    .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
 };