libopenh264enc: Return a more sensible error code in some init failure paths
[ffmpeg.git] / libavcodec / h264_mvpred.h
index 4684077..83b1ea6 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * H.26L/H.264/AVC/JVT/14496-10/... motion vector predicion
+ * H.26L/H.264/AVC/JVT/14496-10/... motion vector prediction
  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
  *
  * This file is part of Libav.
@@ -21,7 +21,7 @@
 
 /**
  * @file
- * H.264 / AVC / MPEG4 part10 motion vector predicion.
+ * H.264 / AVC / MPEG-4 part10 motion vector prediction.
  * @author Michael Niedermayer <michaelni@gmx.at>
  */
 
 
 #include "internal.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "mpegutils.h"
 
 #include <assert.h>
 
-static av_always_inline int fetch_diagonal_mv(H264Context *h, H264SliceContext *sl,
+static av_always_inline int fetch_diagonal_mv(const H264Context *h, H264SliceContext *sl,
                                               const int16_t **C,
                                               int i, int list, int part_width)
 {
@@ -62,11 +62,11 @@ static av_always_inline int fetch_diagonal_mv(H264Context *h, H264SliceContext *
             AV_ZERO32(sl->mv_cache[list][scan8[0] - 2]);
             *C = sl->mv_cache[list][scan8[0] - 2];
 
-            if (!MB_FIELD(h) && IS_INTERLACED(sl->left_type[0])) {
+            if (!MB_FIELD(sl) && IS_INTERLACED(sl->left_type[0])) {
                 SET_DIAG_MV(* 2, >> 1, sl->left_mb_xy[0] + h->mb_stride,
-                            (h->mb_y & 1) * 2 + (i >> 5));
+                            (sl->mb_y & 1) * 2 + (i >> 5));
             }
-            if (MB_FIELD(h) && !IS_INTERLACED(sl->left_type[0])) {
+            if (MB_FIELD(sl) && !IS_INTERLACED(sl->left_type[0])) {
                 // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.
                 SET_DIAG_MV(/ 2, << 1, sl->left_mb_xy[i >= 36], ((i >> 2)) & 3);
             }
@@ -78,7 +78,7 @@ static av_always_inline int fetch_diagonal_mv(H264Context *h, H264SliceContext *
         *C = sl->mv_cache[list][i - 8 + part_width];
         return topright_ref;
     } else {
-        tprintf(h->avctx, "topright MV not available\n");
+        ff_tlog(h->avctx, "topright MV not available\n");
 
         *C = sl->mv_cache[list][i - 8 - 1];
         return sl->ref_cache[list][i - 8 - 1];
@@ -92,7 +92,7 @@ static av_always_inline int fetch_diagonal_mv(H264Context *h, H264SliceContext *
  * @param mx the x component of the predicted motion vector
  * @param my the y component of the predicted motion vector
  */
-static av_always_inline void pred_motion(H264Context *const h,
+static av_always_inline void pred_motion(const H264Context *const h,
                                          H264SliceContext *sl,
                                          int n,
                                          int part_width, int list, int ref,
@@ -118,7 +118,7 @@ static av_always_inline void pred_motion(H264Context *const h,
 
     diagonal_ref = fetch_diagonal_mv(h, sl, &C, index8, list, part_width);
     match_count  = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
-    tprintf(h->avctx, "pred_motion match_count=%d\n", match_count);
+    ff_tlog(h->avctx, "pred_motion match_count=%d\n", match_count);
     if (match_count > 1) { //most common
         *mx = mid_pred(A[0], B[0], C[0]);
         *my = mid_pred(A[1], B[1], C[1]);
@@ -145,10 +145,10 @@ static av_always_inline void pred_motion(H264Context *const h,
         }
     }
 
-    tprintf(h->avctx,
+    ff_tlog(h->avctx,
             "pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n",
             top_ref, B[0], B[1], diagonal_ref, C[0], C[1], left_ref,
-            A[0], A[1], ref, *mx, *my, h->mb_x, h->mb_y, n, list);
+            A[0], A[1], ref, *mx, *my, sl->mb_x, sl->mb_y, n, list);
 }
 
 /**
@@ -157,7 +157,7 @@ static av_always_inline void pred_motion(H264Context *const h,
  * @param mx the x component of the predicted motion vector
  * @param my the y component of the predicted motion vector
  */
-static av_always_inline void pred_16x8_motion(H264Context *const h,
+static av_always_inline void pred_16x8_motion(const H264Context *const h,
                                               H264SliceContext *sl,
                                               int n, int list, int ref,
                                               int *const mx, int *const my)
@@ -166,8 +166,8 @@ static av_always_inline void pred_16x8_motion(H264Context *const h,
         const int top_ref      = sl->ref_cache[list][scan8[0] - 8];
         const int16_t *const B = sl->mv_cache[list][scan8[0] - 8];
 
-        tprintf(h->avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n",
-                top_ref, B[0], B[1], h->mb_x, h->mb_y, n, list);
+        ff_tlog(h->avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n",
+                top_ref, B[0], B[1], sl->mb_x, sl->mb_y, n, list);
 
         if (top_ref == ref) {
             *mx = B[0];
@@ -178,8 +178,8 @@ static av_always_inline void pred_16x8_motion(H264Context *const h,
         const int left_ref     = sl->ref_cache[list][scan8[8] - 1];
         const int16_t *const A = sl->mv_cache[list][scan8[8] - 1];
 
-        tprintf(h->avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n",
-                left_ref, A[0], A[1], h->mb_x, h->mb_y, n, list);
+        ff_tlog(h->avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n",
+                left_ref, A[0], A[1], sl->mb_x, sl->mb_y, n, list);
 
         if (left_ref == ref) {
             *mx = A[0];
@@ -198,7 +198,7 @@ static av_always_inline void pred_16x8_motion(H264Context *const h,
  * @param mx the x component of the predicted motion vector
  * @param my the y component of the predicted motion vector
  */
-static av_always_inline void pred_8x16_motion(H264Context *const h,
+static av_always_inline void pred_8x16_motion(const H264Context *const h,
                                               H264SliceContext *sl,
                                               int n, int list, int ref,
                                               int *const mx, int *const my)
@@ -207,8 +207,8 @@ static av_always_inline void pred_8x16_motion(H264Context *const h,
         const int left_ref     = sl->ref_cache[list][scan8[0] - 1];
         const int16_t *const A = sl->mv_cache[list][scan8[0] - 1];
 
-        tprintf(h->avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n",
-                left_ref, A[0], A[1], h->mb_x, h->mb_y, n, list);
+        ff_tlog(h->avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n",
+                left_ref, A[0], A[1], sl->mb_x, sl->mb_y, n, list);
 
         if (left_ref == ref) {
             *mx = A[0];
@@ -221,8 +221,8 @@ static av_always_inline void pred_8x16_motion(H264Context *const h,
 
         diagonal_ref = fetch_diagonal_mv(h, sl, &C, scan8[4], list, 2);
 
-        tprintf(h->avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n",
-                diagonal_ref, C[0], C[1], h->mb_x, h->mb_y, n, list);
+        ff_tlog(h->avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n",
+                diagonal_ref, C[0], C[1], sl->mb_x, sl->mb_y, n, list);
 
         if (diagonal_ref == ref) {
             *mx = C[0];
@@ -237,7 +237,7 @@ static av_always_inline void pred_8x16_motion(H264Context *const h,
 
 #define FIX_MV_MBAFF(type, refn, mvn, idx)      \
     if (FRAME_MBAFF(h)) {                       \
-        if (MB_FIELD(h)) {                      \
+        if (MB_FIELD(sl)) {                     \
             if (!IS_INTERLACED(type)) {         \
                 refn <<= 1;                     \
                 AV_COPY32(mvbuf[idx], mvn);     \
@@ -254,7 +254,7 @@ static av_always_inline void pred_8x16_motion(H264Context *const h,
         }                                       \
     }
 
-static av_always_inline void pred_pskip_motion(H264Context *const h,
+static av_always_inline void pred_pskip_motion(const H264Context *const h,
                                                H264SliceContext *sl)
 {
     DECLARE_ALIGNED(4, static const int16_t, zeromv)[2] = { 0 };
@@ -298,8 +298,8 @@ static av_always_inline void pred_pskip_motion(H264Context *const h,
         goto zeromv;
     }
 
-    tprintf(h->avctx, "pred_pskip: (%d) (%d) at %2d %2d\n",
-            top_ref, left_ref, h->mb_x, h->mb_y);
+    ff_tlog(h->avctx, "pred_pskip: (%d) (%d) at %2d %2d\n",
+            top_ref, left_ref, sl->mb_x, sl->mb_y);
 
     if (USES_LIST(sl->topright_type, 0)) {
         diagonal_ref = ref[4 * sl->topright_mb_xy + 2];
@@ -325,7 +325,7 @@ static av_always_inline void pred_pskip_motion(H264Context *const h,
     }
 
     match_count = !diagonal_ref + !top_ref + !left_ref;
-    tprintf(h->avctx, "pred_pskip_motion match_count=%d\n", match_count);
+    ff_tlog(h->avctx, "pred_pskip_motion match_count=%d\n", match_count);
     if (match_count > 1) {
         mx = mid_pred(A[0], B[0], C[0]);
         my = mid_pred(A[1], B[1], C[1]);
@@ -353,9 +353,9 @@ zeromv:
     return;
 }
 
-static void fill_decode_neighbors(H264Context *h, H264SliceContext *sl, int mb_type)
+static void fill_decode_neighbors(const H264Context *h, H264SliceContext *sl, int mb_type)
 {
-    const int mb_xy = h->mb_xy;
+    const int mb_xy = sl->mb_xy;
     int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
     static const uint8_t left_block_options[4][32] = {
         { 0, 1, 2, 3, 7, 10, 8, 11, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4, 1 + 4 * 4, 1 + 8 * 4, 1 + 5 * 4, 1 + 9 * 4 },
@@ -366,7 +366,7 @@ static void fill_decode_neighbors(H264Context *h, H264SliceContext *sl, int mb_t
 
     sl->topleft_partition = -1;
 
-    top_xy = mb_xy - (h->mb_stride << MB_FIELD(h));
+    top_xy = mb_xy - (h->mb_stride << MB_FIELD(sl));
 
     /* Wow, what a mess, why didn't they simplify the interlacing & intra
      * stuff, I can't imagine that these complex rules are worth it. */
@@ -378,7 +378,7 @@ static void fill_decode_neighbors(H264Context *h, H264SliceContext *sl, int mb_t
     if (FRAME_MBAFF(h)) {
         const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
         const int curr_mb_field_flag = IS_INTERLACED(mb_type);
-        if (h->mb_y & 1) {
+        if (sl->mb_y & 1) {
             if (left_mb_field_flag != curr_mb_field_flag) {
                 left_xy[LBOT] = left_xy[LTOP] = mb_xy - h->mb_stride - 1;
                 if (curr_mb_field_flag) {
@@ -442,7 +442,7 @@ static void fill_decode_neighbors(H264Context *h, H264SliceContext *sl, int mb_t
         sl->topright_type = 0;
 }
 
-static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type)
+static void fill_decode_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
 {
     int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
     int topleft_type, top_type, topright_type, left_type[LEFT_MBS];
@@ -464,7 +464,7 @@ static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type
 
     if (!IS_SKIP(mb_type)) {
         if (IS_INTRA(mb_type)) {
-            int type_mask = h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;
+            int type_mask = h->ps.pps->constrained_intra_pred ? IS_INTRA(-1) : -1;
             sl->topleft_samples_available     =
                 sl->top_samples_available     =
                     sl->left_samples_available = 0xFFFF;
@@ -589,16 +589,16 @@ static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type
         if (CABAC(h)) {
             // top_cbp
             if (top_type)
-                h->top_cbp = h->cbp_table[top_xy];
+                sl->top_cbp = h->cbp_table[top_xy];
             else
-                h->top_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;
+                sl->top_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;
             // left_cbp
             if (left_type[LTOP]) {
-                h->left_cbp =   (h->cbp_table[left_xy[LTOP]] & 0x7F0) |
+                sl->left_cbp =   (h->cbp_table[left_xy[LTOP]] & 0x7F0) |
                                ((h->cbp_table[left_xy[LTOP]] >> (left_block[0] & (~1))) & 2) |
                               (((h->cbp_table[left_xy[LBOT]] >> (left_block[2] & (~1))) & 2) << 2);
             } else {
-                h->left_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;
+                sl->left_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;
             }
         }
     }
@@ -688,8 +688,8 @@ static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type
                 continue;
 
             if (!(mb_type & (MB_TYPE_SKIP | MB_TYPE_DIRECT2))) {
-                uint8_t(*mvd_cache)[2]   = &h->mvd_cache[list][scan8[0]];
-                uint8_t(*mvd)[2]         = h->mvd_table[list];
+                uint8_t(*mvd_cache)[2]   = &sl->mvd_cache[list][scan8[0]];
+                uint8_t(*mvd)[2]         = sl->mvd_table[list];
                 ref_cache[2 + 8 * 0] =
                 ref_cache[2 + 8 * 2] = PART_NOT_AVAILABLE;
                 AV_ZERO32(mv_cache[2 + 8 * 0]);
@@ -721,7 +721,7 @@ static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type
                     AV_ZERO16(mvd_cache[2 + 8 * 0]);
                     AV_ZERO16(mvd_cache[2 + 8 * 2]);
                     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
-                        uint8_t *direct_cache = &h->direct_cache[scan8[0]];
+                        uint8_t *direct_cache = &sl->direct_cache[scan8[0]];
                         uint8_t *direct_table = h->direct_table;
                         fill_rectangle(direct_cache, 4, 4, 8, MB_TYPE_16x16 >> 1, 1);
 
@@ -767,13 +767,13 @@ static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type
     MAP_F2F(scan8[0] - 1 + 3 * 8, left_type[LBOT])
 
             if (FRAME_MBAFF(h)) {
-                if (MB_FIELD(h)) {
+                if (MB_FIELD(sl)) {
 
 #define MAP_F2F(idx, mb_type)                                           \
     if (!IS_INTERLACED(mb_type) && sl->ref_cache[list][idx] >= 0) {     \
         sl->ref_cache[list][idx]    <<= 1;                              \
         sl->mv_cache[list][idx][1]   /= 2;                              \
-        h->mvd_cache[list][idx][1] >>= 1;                               \
+        sl->mvd_cache[list][idx][1] >>= 1;                              \
     }
 
                     MAP_MVS
@@ -784,7 +784,7 @@ static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type
     if (IS_INTERLACED(mb_type) && sl->ref_cache[list][idx] >= 0) {      \
         sl->ref_cache[list][idx]    >>= 1;                              \
         sl->mv_cache[list][idx][1]  <<= 1;                              \
-        h->mvd_cache[list][idx][1] <<= 1;                               \
+        sl->mvd_cache[list][idx][1] <<= 1;                              \
     }
 
                     MAP_MVS
@@ -800,14 +800,14 @@ static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type
 /**
  * decodes a P_SKIP or B_SKIP macroblock
  */
-static void av_unused decode_mb_skip(H264Context *h, H264SliceContext *sl)
+static void av_unused decode_mb_skip(const H264Context *h, H264SliceContext *sl)
 {
-    const int mb_xy = h->mb_xy;
+    const int mb_xy = sl->mb_xy;
     int mb_type     = 0;
 
     memset(h->non_zero_count[mb_xy], 0, 48);
 
-    if (MB_FIELD(h))
+    if (MB_FIELD(sl))
         mb_type |= MB_TYPE_INTERLACED;
 
     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {