Initial checkins of the mpeg4 and h263 software decoders based on PV

45 files changed, 21128 insertions, 0 deletions

diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/adaptive_smooth_no_mmx.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/adaptive_smooth_no_mmx.cpp
new file mode 100644
index 0000000..e2761eb
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/adaptive_smooth_no_mmx.cpp
@@ -0,0 +1,421 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+
+ Description: Separated modules into one function per file and put into
+    new template.
+
+ Description: Optimizing C code and adding comments.  Also changing variable
+    names to make them more meaningful.
+
+ Who:                   Date:
+ Description:
+
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+
+    Rec_Y = pointer to 0th position in buffer containing luminance values
+        of type uint8.
+    y_start = value of y coordinate of type int that specifies the first
+        row of pixels to be used in the filter algorithm.
+    x_start = value of x coordinate of type int that specifies the first
+        column of pixels to be used in the filter algorithm.
+    y_blk_start = value of the y coordinate of type int that specifies the
+        row of pixels which contains the start of a block. The row
+        specified by y_blk_start+BLK_SIZE is the last row of pixels
+        that are used in the filter algorithm.
+    x_blk_start = value of the x coordinate of type int that specifies the
+        column of pixels which contains the start of a block.  The
+        column specified by x_blk_start+BLK_SIZE is the last column of
+        pixels that are used in the filter algorithm.
+    thr = value of type int that is compared to the elements in Rec_Y to
+        determine if a particular value in Rec_Y will be modified by
+        the filter or not
+    width = value of type int that specifies the width of the display
+        in pixels (or pels, equivalently).
+    max_diff = value of type int that specifies the value that may be added
+        or subtracted from the pixel in Rec_Y that is being filtered
+        if the filter algorithm decides to change that particular
+        pixel's luminance value.
+
+
+ Local Stores/Buffers/Pointers Needed:
+    None
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Outputs:
+    None
+
+ Pointers and Buffers Modified:
+    Buffer pointed to by Rec_Y is modified with the filtered
+    luminance values.
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ This function implements a motion compensated noise filter using adaptive
+ weighted averaging of luminance values.  *Rec_Y contains the luminance values
+ that are being filtered.
+
+ The picture below depicts a 3x3 group of pixel luminance values.  The "u", "c",
+ and "l" stand for "upper", "center" and "lower", respectively.  The location
+ of pelc0 is specified by x_start and y_start in the 1-D array "Rec_Y" as
+ follows (assuming x_start=0):
+
+ location of pelc0 = [(y_start+1) * width] + x_start
+
+ Moving up or down 1 row (moving from pelu2 to pelc2, for example) is done by
+ incrementing or decrementing "width" elements within Rec_Y.
+
+ The coordinates of the upper left hand corner of a block (not the group of
+ 9 pixels depicted in the figure below) is specified by
+ (y_blk_start, x_blk_start).  The width and height of the block is BLKSIZE.
+ (y_start,x_start) may be specified independently of (y_blk_start, x_blk_start).
+
+    (y_start,x_start)
+ -----------|--------------------------
+    |   |   |   |   |
+    |   X   | pelu1 | pelu2 |
+    | pelu0 |   |   |
+    |   |   |   |
+ --------------------------------------
+    |   |   |   |
+    | pelc0 | pelc1 | pelc2 |
+    |   |   |   |
+    |   |   |   |
+ --------------------------------------
+    |   |   |   |
+    | pell0 | pell1 | pell2 |
+    |   |   |   |
+    |   |   |   |
+ --------------------------------------
+
+ The filtering of the luminance values is achieved by comparing the 9
+ luminance values to a threshold value ("thr") and then changing the
+ luminance value of pelc1 if all of the values are above or all of the values
+ are below the threshold.  The amount that the luminance value is changed
+ depends on a weighted sum of the 9 luminance values. The position of Pelc1
+ is then advanced to the right by one (as well as all of the surrounding pixels)
+ and the same calculation is performed again for the luminance value of the new
+ Pelc1. This continues row-wise until pixels in the last row of the block are
+ filtered.
+
+
+------------------------------------------------------------------------------
+ REQUIREMENTS
+
+ None.
+
+------------------------------------------------------------------------------
+ REFERENCES
+
+ ..\corelibs\decoder\common\src\post_proc.c
+
+------------------------------------------------------------------------------
+ PSEUDO-CODE
+
+------------------------------------------------------------------------------
+ RESOURCES USED
+   When the code is written for a specific target processor the
+     the resources used should be documented below.
+
+ STACK USAGE: [stack count for this module] + [variable to represent
+          stack usage for each subroutine called]
+
+     where: [stack usage variable] = stack usage for [subroutine
+         name] (see [filename].ext)
+
+ DATA MEMORY USED: x words
+
+ PROGRAM MEMORY USED: x words
+
+ CLOCK CYCLES: [cycle count equation for this module] + [variable
+           used to represent cycle count for each subroutine
+           called]
+
+     where: [cycle count variable] = cycle count for [subroutine
+        name] (see [filename].ext)
+
+------------------------------------------------------------------------------
+*/
+
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include    "mp4dec_lib.h"
+#include    "post_proc.h"
+#include    "mp4def.h"
+
+#define OSCL_DISABLE_WARNING_CONV_POSSIBLE_LOSS_OF_DATA
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+#ifdef PV_POSTPROC_ON
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+void AdaptiveSmooth_NoMMX(
+    uint8 *Rec_Y,       /* i/o  */
+    int y_start,        /* i    */
+    int x_start,        /* i    */
+    int y_blk_start,    /* i    */
+    int x_blk_start,    /* i    */
+    int thr,        /* i    */
+    int width,      /* i    */
+    int max_diff        /* i    */
+)
+{
+
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int  sign_v[15];
+    int sum_v[15];
+    int *sum_V_ptr;
+    int *sign_V_ptr;
+    uint8 pelu;
+    uint8 pelc;
+    uint8 pell;
+    uint8 *pelp;
+    uint8 oldrow[15];
+    int  sum;
+    int sum1;
+    uint8 *Rec_Y_ptr;
+    int32  addr_v;
+    int row_cntr;
+    int col_cntr;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /*  first row
+    */
+    addr_v = (int32)(y_start + 1) * width;  /* y coord of 1st element in the row  /
+                     /containing pelc pixel /     */
+    Rec_Y_ptr = &Rec_Y[addr_v + x_start];  /* initializing pointer to
+                           /  pelc0 position  */
+    sum_V_ptr = &sum_v[0];  /* initializing pointer to 0th element of array
+                /   that will contain weighted sums of pixel
+                /   luminance values */
+    sign_V_ptr = &sign_v[0];  /*  initializing pointer to 0th element of
+                  /   array that will contain sums that indicate
+                  /    how many of the 9 pixels are above or below
+                  /    the threshold value (thr)    */
+    pelp = &oldrow[0];  /* initializing pointer to the 0th element of array
+                /    that will contain current values of pelc that
+                /   are saved and used as values of pelu when the
+                /   next row of pixels are filtered */
+
+    pelu = *(Rec_Y_ptr - width);  /* assigning value of pelu0 to pelu  */
+    *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc0 to pelc and
+                     /  storing this value in pelp which
+                     /   will be used as value of pelu0 when
+                     /  next row is filtered */
+    pell = *(Rec_Y_ptr + width);  /* assigning value of pell0 to pell */
+    Rec_Y_ptr++; /* advancing pointer from pelc0 to pelc1 */
+    *sum_V_ptr++ = pelu + (pelc << 1) + pell;  /* weighted sum of pelu0,
+                         /  pelc0 and pell0  */
+    /* sum of 0's and 1's (0 if pixel value is below thr, 1 if value
+    /is above thr)  */
+    *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr);
+
+
+    pelu = *(Rec_Y_ptr - width);  /* assigning value of pelu1 to pelu */
+    *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc1 to pelc and
+                     /  storing this value in pelp which
+                     /  will be used as the value of pelu1 when
+                     /  next row is filtered */
+    pell = *(Rec_Y_ptr + width);  /* assigning value of pell1 to pell */
+    Rec_Y_ptr++;  /* advancing pointer from pelc1 to pelc2 */
+    *sum_V_ptr++ = pelu + (pelc << 1) + pell; /* weighted sum of pelu1,
+                        / pelc1 and pell1  */
+    /* sum of 0's and 1's (0 if pixel value is below thr, 1 if value
+    /is above thr)  */
+    *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr);
+
+    /* The loop below performs the filtering for the first row of
+    /   pixels in the region.  It steps across the remaining pixels in
+    /   the row and alters the luminance value of pelc1 if necessary,
+    /   depending on the luminance values of the adjacent pixels*/
+
+    for (col_cntr = (x_blk_start + BLKSIZE - 1) - x_start; col_cntr > 0; col_cntr--)
+    {
+        pelu = *(Rec_Y_ptr - width);  /* assigning value of pelu2 to
+                        /   pelu */
+        *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc2 to pelc
+                         / and storing this value in pelp
+                         / which will be used   as value of pelu2
+                         / when next row is filtered */
+        pell = *(Rec_Y_ptr + width); /* assigning value of pell2 to pell */
+
+        /* weighted sum of pelu1, pelc1 and pell1  */
+        *sum_V_ptr = pelu + (pelc << 1) + pell;
+        /* sum of 0's and 1's (0 if pixel value is below thr,
+        /1 if value is above thr)  */
+        *sign_V_ptr = INDEX(pelu, thr) + INDEX(pelc, thr) +
+                      INDEX(pell, thr);
+        /* the value of sum1 indicates how many of the 9 pixels'
+        /luminance values are above or equal to thr */
+        sum1 = *(sign_V_ptr - 2) + *(sign_V_ptr - 1) + *sign_V_ptr;
+
+        /* alter the luminance value of pelc1 if all 9 luminance values
+        /are above or equal to thr or if all 9 values are below thr */
+        if (sum1 == 0 || sum1 == 9)
+        {
+            /* sum is a weighted average of the 9 pixel luminance
+            /values   */
+            sum = (*(sum_V_ptr - 2) + (*(sum_V_ptr - 1) << 1) +
+                   *sum_V_ptr + 8) >> 4;
+
+            Rec_Y_ptr--;  /* move pointer back to pelc1  */
+            /* If luminance value of pelc1 is larger than
+            / sum by more than max_diff, then subract max_diff
+            / from luminance value of pelc1*/
+            if ((int)(*Rec_Y_ptr - sum) > max_diff)
+            {
+                sum = *Rec_Y_ptr - max_diff;
+            }
+            /* If luminance value of pelc1 is smaller than
+            / sum by more than max_diff, then add max_diff
+            / to luminance value of pelc1*/
+            else if ((int)(*Rec_Y_ptr - sum) < -max_diff)
+            {
+                sum = *Rec_Y_ptr + max_diff;
+            }
+            *Rec_Y_ptr++ = sum; /* assign value of sum to pelc1
+                         and advance pointer to pelc2 */
+        }
+        Rec_Y_ptr++; /* advance pointer to new value of pelc2
+                 /   old pelc2 is now treated as pelc1*/
+        sum_V_ptr++; /* pointer is advanced so next weighted sum may
+                 /  be saved */
+        sign_V_ptr++; /* pointer is advanced so next sum of 0's and
+                  / 1's may be saved  */
+    }
+
+    /* The nested loops below perform the filtering for the remaining rows */
+
+    addr_v = (y_start + 2) * width;  /* advance addr_v to the next row
+                     /   (corresponding to pell0)*/
+    /* The outer loop steps throught the rows.   */
+    for (row_cntr = (y_blk_start + BLKSIZE) - (y_start + 2); row_cntr > 0; row_cntr--)
+    {
+        Rec_Y_ptr = &Rec_Y[addr_v + x_start]; /* advance pointer to
+            /the old pell0, which has become the new pelc0 */
+        addr_v += width;  /* move addr_v down 1 row */
+        sum_V_ptr = &sum_v[0];  /* re-initializing pointer */
+        sign_V_ptr = &sign_v[0];  /* re-initilaizing pointer */
+        pelp = &oldrow[0]; /* re-initializing pointer */
+
+        pelu = *pelp; /* setting pelu0 to old value of pelc0 */
+        *pelp++ = pelc = *Rec_Y_ptr;
+        pell = *(Rec_Y_ptr + width);
+        Rec_Y_ptr++;
+        *sum_V_ptr++ = pelu + (pelc << 1) + pell;
+        *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) +
+                        INDEX(pell, thr);
+
+        pelu = *pelp; /* setting pelu1 to old value of pelc1 */
+        *pelp++ = pelc = *Rec_Y_ptr;
+        pell = *(Rec_Y_ptr + width);
+        Rec_Y_ptr++;
+        *sum_V_ptr++ = pelu + (pelc << 1) + pell;
+        *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) +
+                        INDEX(pell, thr);
+        /* The inner loop steps through the columns */
+        for (col_cntr = (x_blk_start + BLKSIZE - 1) - x_start; col_cntr > 0; col_cntr--)
+        {
+            pelu = *pelp; /* setting pelu2 to old value of pelc2 */
+            *pelp++ = pelc = *Rec_Y_ptr;
+            pell = *(Rec_Y_ptr + width);
+
+            *sum_V_ptr = pelu + (pelc << 1) + pell;
+            *sign_V_ptr = INDEX(pelu, thr) + INDEX(pelc, thr) +
+                          INDEX(pell, thr);
+
+            sum1 = *(sign_V_ptr - 2) + *(sign_V_ptr - 1) + *sign_V_ptr;
+            /* the "if" statement below is the same as the one in
+            / the first loop */
+            if (sum1 == 0 || sum1 == 9)
+            {
+                sum = (*(sum_V_ptr - 2) + (*(sum_V_ptr - 1) << 1) +
+                       *sum_V_ptr + 8) >> 4;
+
+                Rec_Y_ptr--;
+                if ((int)(*Rec_Y_ptr - sum) > max_diff)
+                {
+                    sum = *Rec_Y_ptr - max_diff;
+                }
+                else if ((int)(*Rec_Y_ptr - sum) < -max_diff)
+                {
+                    sum = *Rec_Y_ptr + max_diff;
+                }
+                *Rec_Y_ptr++ = (uint8) sum;
+            }
+            Rec_Y_ptr++;
+            sum_V_ptr++;
+            sign_V_ptr++;
+        }
+    }
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/bitstream.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/bitstream.cpp
new file mode 100644
index 0000000..37250f3
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/bitstream.cpp
@@ -0,0 +1,1001 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "bitstream.h"
+#include "mp4dec_lib.h"
+
+
+#define OSCL_DISABLE_WARNING_CONDITIONAL_IS_CONSTANT
+/* to mask the n least significant bits of an integer */
+static const uint32 msk[33] =
+{
+    0x00000000, 0x00000001, 0x00000003, 0x00000007,
+    0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
+    0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
+    0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
+    0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
+    0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
+    0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
+    0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
+    0xffffffff
+};
+
+
+/* ======================================================================== */
+/*  Function : BitstreamFillCache()                                         */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : Read more bitstream data into buffer & the 24-byte cache.    */
+/*              This function is different from BitstreamFillBuffer in      */
+/*              that the buffer is the frame-based buffer provided by       */
+/*              the application.                                            */
+/*  In/out   :                                                              */
+/*  Return   : PV_SUCCESS if successed, PV_FAIL if failed.                  */
+/*  Modified : 4/16/01  : removed return of PV_END_OF_BUFFER                */
+/* ======================================================================== */
+PV_STATUS BitstreamFillCache(BitstreamDecVideo *stream)
+{
+    uint8 *bitstreamBuffer = stream->bitstreamBuffer;
+    uint8 *v;
+    int num_bits, i;
+
+    stream->curr_word |= (stream->next_word >> stream->incnt);   // stream->incnt cannot be 32
+    stream->next_word <<= (31 - stream->incnt);
+    stream->next_word <<= 1;
+    num_bits = stream->incnt_next + stream->incnt;
+    if (num_bits >= 32)
+    {
+        stream->incnt_next -= (32 - stream->incnt);
+        stream->incnt = 32;
+        return PV_SUCCESS;
+    }
+    /* this check can be removed if there is additional extra 4 bytes at the end of the bitstream */
+    v = bitstreamBuffer + stream->read_point;
+
+    if (stream->read_point > stream->data_end_pos - 4)
+    {
+        if (stream->data_end_pos <= stream->read_point)
+        {
+            stream->incnt = num_bits;
+            stream->incnt_next = 0;
+            return PV_SUCCESS;
+        }
+
+        stream->next_word = 0;
+
+        for (i = 0; i < stream->data_end_pos - stream->read_point; i++)
+        {
+            stream->next_word |= (v[i] << ((3 - i) << 3));
+        }
+
+        stream->read_point = stream->data_end_pos;
+        stream->curr_word |= (stream->next_word >> num_bits); // this is safe
+
+        stream->next_word <<= (31 - num_bits);
+        stream->next_word <<= 1;
+        num_bits = i << 3;
+        stream->incnt += stream->incnt_next;
+        stream->incnt_next = num_bits - (32 - stream->incnt);
+        if (stream->incnt_next < 0)
+        {
+            stream->incnt +=  num_bits;
+            stream->incnt_next = 0;
+        }
+        else
+        {
+            stream->incnt = 32;
+        }
+        return PV_SUCCESS;
+    }
+
+    stream->next_word = ((uint32)v[0] << 24) | (v[1] << 16) | (v[2] << 8) | v[3];
+    stream->read_point += 4;
+
+    stream->curr_word |= (stream->next_word >> num_bits); // this is safe
+    stream->next_word <<= (31 - num_bits);
+    stream->next_word <<= 1;
+    stream->incnt_next += stream->incnt;
+    stream->incnt = 32;
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : BitstreamReset()                                             */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : Initialize the bitstream buffer for frame-based decoding.    */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+void BitstreamReset(BitstreamDecVideo *stream, uint8 *buffer, int32 buffer_size)
+{
+    /* set up frame-based bitstream buffer */
+    oscl_memset(stream, 0, sizeof(BitstreamDecVideo));
+    stream->data_end_pos = buffer_size;
+    stream->bitstreamBuffer = buffer;
+}
+
+
+/* ======================================================================== */
+/*  Function : BitstreamOpen()                                              */
+/*  Purpose  : Initialize the bitstream data structure.                     */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+int BitstreamOpen(BitstreamDecVideo *stream, int)
+{
+    int buffer_size = 0;
+    /* set up linear bitstream buffer */
+//  stream->currentBytePos = 0;
+    stream->data_end_pos = 0;
+
+    stream->incnt = 0;
+    stream->incnt_next = 0;
+    stream->bitcnt = 0;
+    stream->curr_word = stream->next_word = 0;
+    stream->read_point = stream->data_end_pos;
+    return buffer_size;
+}
+
+
+/* ======================================================================== */
+/*  Function : BitstreamClose()                                             */
+/*  Purpose  : Cleanup the bitstream data structure.                        */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+void BitstreamClose(BitstreamDecVideo *)
+{
+    return;
+}
+
+
+/***********************************************************CommentBegin******
+*
+* -- BitstreamShowBits32HC
+* Shows 32 bits
+***********************************************************CommentEnd********/
+
+PV_STATUS BitstreamShowBits32HC(BitstreamDecVideo *stream, uint32 *code)
+{
+    PV_STATUS status = PV_SUCCESS;
+
+    if (stream->incnt < 32)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+    *code = stream->curr_word;
+    return status;
+}
+
+/***********************************************************CommentBegin******
+*
+* -- BitstreamShowBits32
+* Shows upto and including 31 bits
+***********************************************************CommentEnd********/
+PV_STATUS BitstreamShowBits32(BitstreamDecVideo *stream, int nbits, uint32 *code)
+{
+    PV_STATUS status = PV_SUCCESS;
+
+    if (stream->incnt < nbits)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+    *code = stream->curr_word >> (32 - nbits);
+    return status;
+}
+
+
+#ifndef PV_BS_INLINE
+/*========================================================================= */
+/*  Function:   BitstreamShowBits16()                                       */
+/*  Date:       12/18/2000                                                  */
+/*  Purpose:    To see the next "nbits"(nbits<=16) bitstream bits           */
+/*              without advancing the read pointer                          */
+/*                                                                          */
+/* =========================================================================*/
+PV_STATUS BitstreamShowBits16(BitstreamDecVideo *stream, int nbits, uint *code)
+{
+    PV_STATUS status = PV_SUCCESS;
+
+
+    if (stream->incnt < nbits)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+
+    *code = stream->curr_word >> (32 - nbits);
+    return status;
+}
+
+
+/*========================================================================= */
+/*  Function:   BitstreamShow15Bits()                                       */
+/*  Date:       01/23/2001                                                  */
+/*  Purpose:    To see the next 15 bitstream bits                           */
+/*              without advancing the read pointer                          */
+/*                                                                          */
+/* =========================================================================*/
+PV_STATUS BitstreamShow15Bits(BitstreamDecVideo *stream, uint *code)
+{
+    PV_STATUS status = PV_SUCCESS;
+
+    if (stream->incnt < 15)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+    *code = stream->curr_word >> 17;
+    return status;
+}
+/*========================================================================= */
+/*  Function: BitstreamShow13Bits                                           */
+/*  Date:       050923                                              */
+/*  Purpose:    Faciliate and speed up showing 13 bit from bitstream        */
+/*              used in VlcTCOEFF decoding                                  */
+/*  Modified:                            */
+/* =========================================================================*/
+PV_STATUS BitstreamShow13Bits(BitstreamDecVideo *stream, uint *code)
+{
+    PV_STATUS status = PV_SUCCESS;
+
+    if (stream->incnt < 13)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+    *code = stream->curr_word >> 19;
+    return status;
+}
+
+uint BitstreamReadBits16_INLINE(BitstreamDecVideo *stream, int nbits)
+{
+    uint code;
+    PV_STATUS status;
+
+    if (stream->incnt < nbits)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+    code = stream->curr_word >> (32 - nbits);
+    PV_BitstreamFlushBits(stream, nbits);
+    return code;
+}
+
+
+uint BitstreamRead1Bits_INLINE(BitstreamDecVideo *stream)
+{
+    PV_STATUS status = PV_SUCCESS;
+    uint    code;
+
+
+    if (stream->incnt < 1)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+    code = stream->curr_word >> 31;
+    PV_BitstreamFlushBits(stream, 1);
+
+    return code;
+}
+
+#endif
+
+/* ======================================================================== */
+/*  Function : BitstreamReadBits16()                                        */
+/*  Purpose  : Read bits (nbits <=16) from bitstream buffer.                */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/* ======================================================================== */
+uint BitstreamReadBits16(BitstreamDecVideo *stream, int nbits)
+{
+    uint code;
+
+    if (stream->incnt < nbits)
+    {
+        /* frame-based decoding */
+        BitstreamFillCache(stream);
+    }
+    code = stream->curr_word >> (32 - nbits);
+    PV_BitstreamFlushBits(stream, nbits);
+    return code;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamRead1Bits()                                         */
+/*  Date     : 10/23/2000                                                   */
+/*  Purpose  : Faciliate and speed up reading 1 bit from bitstream.         */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/* ======================================================================== */
+
+uint BitstreamRead1Bits(BitstreamDecVideo *stream)
+{
+    uint    code;
+
+    if (stream->incnt < 1)
+    {
+        /* frame-based decoding */
+        BitstreamFillCache(stream);
+    }
+    code = stream->curr_word >> 31;
+    PV_BitstreamFlushBits(stream, 1);
+
+    return code;
+}
+
+/* ======================================================================== */
+/*  Function : PV_BitstreamFlushBitsCheck()                                 */
+/*  Purpose  : Flush nbits bits from bitstream buffer. Check for cache      */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS PV_BitstreamFlushBitsCheck(BitstreamDecVideo *stream, int nbits)
+{
+    PV_STATUS status = PV_SUCCESS;
+
+    stream->bitcnt += nbits;
+    stream->incnt -= nbits;
+    if (stream->incnt < 0)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+
+        if (stream->incnt < 0)
+        {
+            stream->bitcnt += stream->incnt;
+            stream->incnt = 0;
+        }
+    }
+    stream->curr_word <<= nbits;
+    return status;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamReadBits32()                                        */
+/*  Purpose  : Read bits from bitstream buffer.                             */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/* ======================================================================== */
+uint32 BitstreamReadBits32(BitstreamDecVideo *stream, int nbits)
+{
+    uint32 code;
+
+    if (stream->incnt < nbits)
+    {
+        /* frame-based decoding */
+        BitstreamFillCache(stream);
+    }
+    code = stream->curr_word >> (32 - nbits);
+    PV_BitstreamFlushBits(stream, nbits);
+    return code;
+}
+
+uint32 BitstreamReadBits32HC(BitstreamDecVideo *stream)
+{
+    uint32 code;
+
+    BitstreamShowBits32HC(stream, &code);
+    stream->bitcnt += 32;
+    stream->incnt = 0;
+    stream->curr_word = 0;
+    return code;
+}
+
+/* ======================================================================== */
+/*  Function : BitstreamCheckEndBuffer()                                    */
+/*  Date     : 03/30/2001                                                   */
+/*  Purpose  : Check to see if we are at the end of buffer                  */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS BitstreamCheckEndBuffer(BitstreamDecVideo *stream)
+{
+    if (stream->read_point >= stream->data_end_pos && stream->incnt <= 0) return PV_END_OF_VOP;
+    return PV_SUCCESS;
+}
+
+
+PV_STATUS PV_BitstreamShowBitsByteAlign(BitstreamDecVideo *stream, int nbits, uint32 *code)
+{
+    PV_STATUS status = PV_SUCCESS;
+
+    int n_stuffed;
+
+    n_stuffed = 8 - (stream->bitcnt & 0x7); /*  07/05/01 */
+
+    if (stream->incnt < (nbits + n_stuffed))
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+
+    *code = (stream->curr_word << n_stuffed) >> (32 - nbits);
+    return status;
+}
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+PV_STATUS PV_BitstreamShowBitsByteAlignNoForceStuffing(BitstreamDecVideo *stream, int nbits, uint32 *code)
+{
+    PV_STATUS status = PV_SUCCESS;
+
+    int n_stuffed;
+
+    n_stuffed = (8 - (stream->bitcnt & 0x7)) & 7;
+
+    if (stream->incnt < (nbits + n_stuffed))
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+
+    *code = (stream->curr_word << n_stuffed) >> (32 - nbits);
+    return status;
+}
+#endif
+
+PV_STATUS PV_BitstreamByteAlign(BitstreamDecVideo *stream)
+{
+    PV_STATUS status = PV_SUCCESS;
+    int n_stuffed;
+
+    n_stuffed = 8 - (stream->bitcnt & 0x7); /*  07/05/01 */
+
+    /* We have to make sure we have enough bits in the cache.   08/15/2000 */
+    if (stream->incnt < n_stuffed)
+    {
+        /* frame-based decoding */
+        status = BitstreamFillCache(stream);
+    }
+
+
+    stream->bitcnt += n_stuffed;
+    stream->incnt -= n_stuffed;
+    stream->curr_word <<= n_stuffed;
+    if (stream->incnt < 0)
+    {
+        stream->bitcnt += stream->incnt;
+        stream->incnt = 0;
+    }
+    return status;
+}
+
+
+PV_STATUS BitstreamByteAlignNoForceStuffing(BitstreamDecVideo *stream)
+{
+    uint n_stuffed;
+
+    n_stuffed = (8 - (stream->bitcnt & 0x7)) & 0x7; /*  07/05/01 */
+
+    stream->bitcnt += n_stuffed;
+    stream->incnt -= n_stuffed;
+
+    if (stream->incnt < 0)
+    {
+        stream->bitcnt += stream->incnt;
+        stream->incnt = 0;
+    }
+    stream->curr_word <<= n_stuffed;
+    return PV_SUCCESS;
+}
+
+
+/* ==================================================================== */
+/*  Function : getPointer()                                             */
+/*  Date     : 10/98                                                    */
+/*  Purpose  : get current position of file pointer                     */
+/*  In/out   :                                                          */
+/*  Return   :                                                          */
+/* ==================================================================== */
+int32 getPointer(BitstreamDecVideo *stream)
+{
+    return stream->bitcnt;
+}
+
+
+
+
+/* ====================================================================== /
+Function : movePointerTo()
+Date     : 05/14/2004
+Purpose  : move bitstream pointer to a desired position
+In/out   :
+Return   :
+Modified :
+/ ====================================================================== */
+PV_STATUS movePointerTo(BitstreamDecVideo *stream, int32 pos)
+{
+    int32 byte_pos;
+    if (pos < 0)
+    {
+        pos = 0;
+    }
+
+    byte_pos = pos >> 3;
+
+    if (byte_pos > stream->data_end_pos)
+    {
+        byte_pos = stream->data_end_pos;
+    }
+
+    stream->read_point = byte_pos & -4;
+    stream->bitcnt = stream->read_point << 3;;
+    stream->curr_word = 0;
+    stream->next_word = 0;
+    stream->incnt = 0;
+    stream->incnt_next = 0;
+    BitstreamFillCache(stream);
+    PV_BitstreamFlushBits(stream, ((pos & 0x7) + ((byte_pos & 0x3) << 3)));
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : validStuffing()                                              */
+/*  Date     : 04/11/2000                                                   */
+/*  Purpose  : Check whether we have valid stuffing at current position.    */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified : 12/18/2000 : changed the pattern type to uint    */
+/*             04/01/2001 : removed PV_END_OF_BUFFER                        */
+/* ======================================================================== */
+Bool validStuffing(BitstreamDecVideo *stream)
+{
+    uint n_stuffed;
+    uint pattern;
+
+
+    n_stuffed = 8 - (stream->bitcnt & 0x7);
+    BitstreamShowBits16(stream, n_stuffed, &pattern);
+    if (pattern == msk[n_stuffed-1]) return PV_TRUE;
+    return PV_FALSE;
+}
+#ifdef PV_ANNEX_IJKT_SUPPORT
+Bool validStuffing_h263(BitstreamDecVideo *stream)
+{
+    uint n_stuffed;
+    uint pattern;
+
+
+    n_stuffed = (8 - (stream->bitcnt & 0x7)) & 7;  //  stream->incnt % 8
+    if (n_stuffed == 0)
+    {
+        return PV_TRUE;
+    }
+    BitstreamShowBits16(stream, n_stuffed, &pattern);
+    if (pattern == 0) return PV_TRUE;
+    return PV_FALSE;
+}
+#endif
+
+
+/* ======================================================================== */
+/*  Function : PVSearchNextH263Frame()                                      */
+/*  Date     : 04/08/2005                                                   */
+/*  Purpose  : search for 0x00 0x00 0x80                                    */
+/*  In/out   :                                                              */
+/*  Return   : PV_SUCCESS if succeeded  or PV_END_OF_VOP if failed          */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS PVSearchNextH263Frame(BitstreamDecVideo *stream)
+{
+    PV_STATUS status = PV_SUCCESS;
+    uint8 *ptr;
+    int32 i;
+    int32 initial_byte_aligned_position = (stream->bitcnt + 7) >> 3;
+
+    ptr = stream->bitstreamBuffer + initial_byte_aligned_position;
+
+    i = PVLocateH263FrameHeader(ptr, stream->data_end_pos - initial_byte_aligned_position);
+    if (stream->data_end_pos <= initial_byte_aligned_position + i)
+    {
+        status = PV_END_OF_VOP;
+    }
+    (void)movePointerTo(stream, ((i + initial_byte_aligned_position) << 3)); /* ptr + i */
+    return status;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVSearchNextM4VFrame()                                       */
+/*  Date     : 04/08/2005                                                   */
+/*  Purpose  : search for 0x00 0x00 0x01 and move the pointer to the        */
+/*  beginning of the start code                                             */
+/*  In/out   :                                                              */
+/*  Return   : PV_SUCCESS if succeeded  or PV_END_OF_VOP if failed          */
+/*  Modified :                                                              */
+/* ======================================================================== */
+
+PV_STATUS PVSearchNextM4VFrame(BitstreamDecVideo *stream)
+{
+    PV_STATUS status = PV_SUCCESS;
+    uint8 *ptr;
+    int32 i;
+    int32 initial_byte_aligned_position = (stream->bitcnt + 7) >> 3;
+
+    ptr = stream->bitstreamBuffer + initial_byte_aligned_position;
+
+    i = PVLocateFrameHeader(ptr, stream->data_end_pos - initial_byte_aligned_position);
+    if (stream->data_end_pos <= initial_byte_aligned_position + i)
+    {
+        status = PV_END_OF_VOP;
+    }
+    (void)movePointerTo(stream, ((i + initial_byte_aligned_position) << 3)); /* ptr + i */
+    return status;
+}
+
+
+
+void PVLocateM4VFrameBoundary(BitstreamDecVideo *stream)
+{
+    uint8 *ptr;
+    int32 byte_pos = (stream->bitcnt >> 3);
+
+    stream->searched_frame_boundary = 1;
+    ptr = stream->bitstreamBuffer + byte_pos;
+
+    stream->data_end_pos = PVLocateFrameHeader(ptr, (int32)stream->data_end_pos - byte_pos) + byte_pos;
+}
+
+void PVLocateH263FrameBoundary(BitstreamDecVideo *stream)
+{
+    uint8 *ptr;
+    int32 byte_pos = (stream->bitcnt >> 3);
+
+    stream->searched_frame_boundary = 1;
+    ptr = stream->bitstreamBuffer + byte_pos;
+
+    stream->data_end_pos = PVLocateH263FrameHeader(ptr, (int32)stream->data_end_pos - byte_pos) + byte_pos;
+}
+
+/* ======================================================================== */
+/*  Function : quickSearchVideoPacketHeader()               */
+/*  Date     : 05/08/2000                           */
+/*  Purpose  : Quick search for the next video packet header        */
+/*  In/out   :                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.            */
+/*  Modified :                              */
+/* ======================================================================== */
+PV_STATUS quickSearchVideoPacketHeader(BitstreamDecVideo *stream, int marker_length)
+{
+    PV_STATUS status = PV_SUCCESS;
+    uint32 tmpvar;
+
+
+    if (stream->searched_frame_boundary == 0)
+    {
+        PVLocateM4VFrameBoundary(stream);
+    }
+
+    do
+    {
+        status = BitstreamCheckEndBuffer(stream);
+        if (status == PV_END_OF_VOP) break;
+        PV_BitstreamShowBitsByteAlign(stream, marker_length, &tmpvar);
+        if (tmpvar == RESYNC_MARKER) break;
+        PV_BitstreamFlushBits(stream, 8);
+    }
+    while (status == PV_SUCCESS);
+
+    return status;
+}
+#ifdef PV_ANNEX_IJKT_SUPPORT
+PV_STATUS quickSearchH263SliceHeader(BitstreamDecVideo *stream)
+{
+    PV_STATUS status = PV_SUCCESS;
+    uint32 tmpvar;
+
+
+    if (stream->searched_frame_boundary == 0)
+    {
+        PVLocateH263FrameBoundary(stream);
+    }
+
+    do
+    {
+        status = BitstreamCheckEndBuffer(stream);
+        if (status == PV_END_OF_VOP) break;
+        PV_BitstreamShowBitsByteAlignNoForceStuffing(stream, 17, &tmpvar);
+        if (tmpvar == RESYNC_MARKER) break;
+        PV_BitstreamFlushBits(stream, 8);
+    }
+    while (status == PV_SUCCESS);
+
+    return status;
+}
+#endif
+/* ======================================================================== */
+/*          The following functions are for Error Concealment.              */
+/* ======================================================================== */
+
+/****************************************************/
+//  01/22/99 Quick search of Resync Marker
+// (actually the first part of it, i.e. 16 0's and a 1.
+
+/* We are not using the fastest algorithm possible. What this function does is
+to locate 11 consecutive 0's and then check if the 5 bits before them and
+the 1 bit after them are all 1's.
+*/
+
+//  Table used for quick search of markers. Gives the last `1' in
+// 4 bits. The MSB is bit #1, the LSB is bit #4.
+const int lastOne[] =
+{
+    0,  4,  3,  4,  2,  4,  3,  4,
+    1,  4,  3,  4,  2,  4,  3,  4
+};
+
+//  Table used for quick search of markers. Gives the last `0' in
+// 4 bits. The MSB is bit #1, the LSB is bit #4.
+/*const int lastZero[]=
+{
+    4,  3,  4,  2,  4,  3,  4,  1,
+        4,  3,  4,  2,  4,  3,  4,  0
+};
+*/
+//  Table used for quick search of markers. Gives the first `0' in
+// 4 bits. The MSB is bit #1, the LSB is bit #4.
+const int firstZero[] =
+{
+    1, 1, 1, 1, 1, 1, 1, 1,
+    2, 2, 2, 2, 3, 3, 4, 0
+};
+
+//  Table used for quick search of markers. Gives the first `1' in
+// 4 bits. The MSB is bit #1, the LSB is bit #4.
+const int firstOne[] =
+{
+    0, 4, 3, 3, 2, 2, 2, 2,
+    1, 1, 1, 1, 1, 1, 1, 1
+};
+
+
+/* ======================================================================== */
+/*  Function : quickSearchMarkers()                                         */
+/*  Date     : 01/25/99                                                     */
+/*  Purpose  : Quick search for Motion marker                               */
+/*  In/out   :                                                              */
+/*  Return   : Boolean true of false                                        */
+/*  Modified : 12/18/2000 : 32-bit version                    */
+/* ======================================================================== */
+PV_STATUS quickSearchMotionMarker(BitstreamDecVideo *stream)
+// MM: (11111000000000001)
+{
+    PV_STATUS status;
+    uint32 tmpvar, tmpvar2;
+
+    if (stream->searched_frame_boundary == 0)
+    {
+        PVLocateM4VFrameBoundary(stream);
+    }
+
+    while (TRUE)
+    {
+        status = BitstreamCheckEndBuffer(stream);
+        if (status == PV_END_OF_VOP) return PV_END_OF_VOP;
+
+        BitstreamShowBits32(stream, 17, &tmpvar);
+        if (!tmpvar) return PV_FAIL;
+
+        if (tmpvar & 1) //  Check if the 17th bit from the curr bit pos is a '1'
+        {
+            if (tmpvar == MOTION_MARKER_COMB)
+            {
+                return PV_SUCCESS; //  Found
+            }
+            else
+            {
+                tmpvar >>= 1;
+                tmpvar &= 0xF;
+                PV_BitstreamFlushBits(stream, (int)(12 + firstZero[tmpvar]));
+            }
+        }
+        else
+        {
+            //  01/25/99 Get the first 16 bits
+            tmpvar >>= 1;
+            tmpvar2 = tmpvar & 0xF;
+
+            //  01/26/99 Check bits #13 ~ #16
+            if (tmpvar2)
+            {
+                PV_BitstreamFlushBits(stream, (int)(7 + lastOne[tmpvar2]));
+            }
+            else
+            {
+                tmpvar >>= 4;
+                tmpvar2 = tmpvar & 0xF;
+
+                //  01/26/99 Check bits #9 ~ #12
+                if (tmpvar2)
+                {
+                    PV_BitstreamFlushBits(stream, (int)(3 + lastOne[tmpvar2]));
+                }
+                else
+                {
+                    tmpvar >>= 4;
+                    tmpvar2 = tmpvar & 0xF;
+
+                    //  01/26/99 Check bits #5 ~ #8
+                    // We don't need to check further
+                    // for the first 5 bits should be all 1's
+                    if (lastOne[tmpvar2] < 2)
+                    {
+                        /* we already have too many consecutive 0's. */
+                        /* Go directly pass the last of the 17 bits. */
+                        PV_BitstreamFlushBits(stream, 17);
+                    }
+                    else
+                    {
+                        PV_BitstreamFlushBits(stream, (int)(lastOne[tmpvar2] - 1));
+                    }
+                }
+            }
+        }
+
+    }
+}
+
+/* ======================================================================== */
+/*  Function : quickSearchDCM()                                             */
+/*  Date     : 01/22/99                                                     */
+/*  Purpose  : Quick search for DC Marker                                   */
+/*              We are not using the fastest algorithm possible.  What this */
+/*              function does is to locate 11 consecutive 0's and then      */
+/*              check if the 7 bits before them and the 1 bit after them    */
+/*              are correct.  (actually the first part of it, i.e. 16 0's   */
+/*              and a 1.                                                    */
+/*  In/out   :                                                              */
+/*  Return   : Boolean true of false                                        */
+/*  Modified : 12/18/2000 : 32-bit version                    */
+/* ======================================================================== */
+PV_STATUS quickSearchDCM(BitstreamDecVideo *stream)
+// DCM: (110 1011 0000 0000 0001)
+{
+    PV_STATUS status;
+    uint32 tmpvar, tmpvar2;
+
+    if (stream->searched_frame_boundary == 0)
+    {
+        PVLocateM4VFrameBoundary(stream);
+    }
+
+    while (TRUE)
+    {
+        status = BitstreamCheckEndBuffer(stream);
+        if (status == PV_END_OF_VOP) return PV_END_OF_VOP;
+        BitstreamShowBits32(stream, 19, &tmpvar);
+
+        if (tmpvar & 1) //  Check if the 17th bit from the curr bit pos is a '1'
+        {
+            if (tmpvar == DC_MARKER)
+            {
+                return PV_SUCCESS; //  Found
+            }
+            else
+            {
+                //  01/25/99 We treat the last of the 19 bits as its 7th bit (which is
+                // also a `1'
+                PV_BitstreamFlushBits(stream, 12);
+            }
+        }
+        else
+        {
+            tmpvar >>= 1;
+            tmpvar2 = tmpvar & 0xF;
+
+            if (tmpvar2)
+            {
+                PV_BitstreamFlushBits(stream, (int)(7 + lastOne[tmpvar2]));
+            }
+            else
+            {
+                tmpvar >>= 4;
+                tmpvar2 = tmpvar & 0xF;
+                if (tmpvar2)
+                {
+                    PV_BitstreamFlushBits(stream, (int)(3 + lastOne[tmpvar2]));
+                }
+                else
+                {
+                    tmpvar >>= 4;
+                    tmpvar2 = tmpvar & 0xF;
+                    if (lastOne[tmpvar2] < 2)
+                    {
+                        /* we already have too many consecutive 0's. */
+                        /* Go directly pass the last of the 17 bits. */
+                        PV_BitstreamFlushBits(stream, 19);
+                    }
+                    else
+                    {
+                        PV_BitstreamFlushBits(stream, (int)(lastOne[tmpvar2] - 1));
+                    }
+                }
+            }
+        }
+    }
+}
+
+/* ======================================================================== */
+/*  Function : quickSearchGOBHeader()   0000 0000 0000 0000 1               */
+/*  Date     : 07/06/01                                                     */
+/*  Purpose  : Quick search of GOBHeader (not byte aligned)                 */
+/*  In/out   :                                                              */
+/*  Return   : Integer value indicates type of marker found                 */
+/*  Modified :                                                              */
+/* ======================================================================== */
+PV_STATUS quickSearchGOBHeader(BitstreamDecVideo *stream)
+{
+    PV_STATUS status;
+    int byte0, byte1, byte2, shift, tmpvar;
+
+    BitstreamByteAlignNoForceStuffing(stream);
+
+    if (stream->searched_frame_boundary == 0)
+    {
+        PVLocateH263FrameBoundary(stream);
+    }
+
+    while (TRUE)
+    {
+        status = BitstreamCheckEndBuffer(stream);
+        if (status == PV_END_OF_VOP) return PV_END_OF_VOP;
+
+        if (stream->incnt < 24)
+        {
+            status = BitstreamFillCache(stream);
+        }
+
+
+        byte1 = (stream->curr_word << 8) >> 24;
+        if (byte1 == 0)
+        {
+            byte2 = (stream->curr_word << 16) >> 24;
+            if (byte2)
+            {
+                tmpvar = byte2 >> 4;
+
+                if (tmpvar)
+                {
+                    shift = 9 - firstOne[tmpvar];
+                }
+                else
+                {
+                    shift = 5 - firstOne[byte2];
+                }
+                byte0 = stream->curr_word >> 24;
+                if ((byte0 & msk[shift]) == 0)
+                {
+                    PV_BitstreamFlushBits(stream, 8 - shift);
+                    return PV_SUCCESS;
+                }
+                PV_BitstreamFlushBits(stream, 8);    /* third_byte is not zero */
+            }
+        }
+
+        PV_BitstreamFlushBits(stream, 8);
+    }
+}
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/bitstream.h b/media/libstagefright/codecs/m4v_h263/dec/src/bitstream.h
new file mode 100644
index 0000000..d52fa87
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/bitstream.h
@@ -0,0 +1,174 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+
+#ifndef _BITSTREAM_D_H_
+#define _BITSTREAM_D_H_
+
+#include "mp4dec_lib.h" /* video decoder function prototypes */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+#define PV_BS_INLINE  /* support inline bitstream functions */
+
+#define PV_BitstreamFlushBits(A,B)  {(A)->bitcnt += (B); (A)->incnt -= (B); (A)->curr_word <<= (B);}
+
+    PV_STATUS BitstreamFillBuffer(BitstreamDecVideo *stream);
+    PV_STATUS BitstreamFillCache(BitstreamDecVideo *stream);
+    void BitstreamReset(BitstreamDecVideo *stream, uint8 *buffer, int32 buffer_size);
+    int BitstreamOpen(BitstreamDecVideo *stream, int layer);
+    void BitstreamClose(BitstreamDecVideo *stream);
+
+    PV_STATUS BitstreamShowBits32(BitstreamDecVideo *stream, int nbits, uint32 *code);
+    uint32 BitstreamReadBits32(BitstreamDecVideo *stream, int nbits);
+
+    uint BitstreamReadBits16(BitstreamDecVideo *stream, int nbits);
+    uint BitstreamRead1Bits(BitstreamDecVideo *stream);
+#ifndef PV_BS_INLINE
+    PV_STATUS BitstreamShowBits16(BitstreamDecVideo *stream, int nbits, uint *code);
+    PV_STATUS BitstreamShow15Bits(BitstreamDecVideo *stream, uint *code);
+    PV_STATUS BitstreamShow13Bits(BitstreamDecVideo *stream, uint *code);
+    uint BitstreamReadBits16_INLINE(BitstreamDecVideo *stream, int nbits);
+    uint BitstreamRead1Bits_INLINE(BitstreamDecVideo *stream);
+#else
+    __inline PV_STATUS BitstreamShowBits16(BitstreamDecVideo *stream, int nbits, uint *code)
+    {
+        PV_STATUS status = PV_SUCCESS;
+
+
+        if (stream->incnt < nbits)
+        {
+            /* frame-based decoding */
+            status = BitstreamFillCache(stream);
+        }
+
+        *code = stream->curr_word >> (32 - nbits);
+        return status;
+    }
+
+
+
+    /* =========================================================================*/
+    __inline PV_STATUS BitstreamShow15Bits(BitstreamDecVideo *stream, uint *code)
+    {
+        PV_STATUS status = PV_SUCCESS;
+
+        if (stream->incnt < 15)
+        {
+            /* frame-based decoding */
+            status = BitstreamFillCache(stream);
+        }
+        *code = stream->curr_word >> 17;
+        return status;
+    }
+
+
+    __inline PV_STATUS BitstreamShow13Bits(BitstreamDecVideo *stream, uint *code)
+    {
+        PV_STATUS status = PV_SUCCESS;
+
+        if (stream->incnt < 13)
+        {
+            /* frame-based decoding */
+            status = BitstreamFillCache(stream);
+        }
+        *code = stream->curr_word >> 19;
+        return status;
+    }
+    __inline uint BitstreamReadBits16_INLINE(BitstreamDecVideo *stream, int nbits)
+    {
+        uint code;
+
+        if (stream->incnt < nbits)
+        {
+            /* frame-based decoding */
+            BitstreamFillCache(stream);
+        }
+        code = stream->curr_word >> (32 - nbits);
+        PV_BitstreamFlushBits(stream, nbits);
+        return code;
+    }
+
+
+    __inline uint BitstreamRead1Bits_INLINE(BitstreamDecVideo *stream)
+    {
+        uint    code;
+
+        if (stream->incnt < 1)
+        {
+            /* frame-based decoding */
+            BitstreamFillCache(stream);
+        }
+        code = stream->curr_word >> 31;
+        PV_BitstreamFlushBits(stream, 1);
+
+        return code;
+    }
+
+#endif
+
+
+
+
+
+
+
+    PV_STATUS PV_BitstreamFlushBitsCheck(BitstreamDecVideo *stream, int nbits);
+
+    uint32 BitstreamReadBits32HC(BitstreamDecVideo *stream);
+    PV_STATUS BitstreamShowBits32HC(BitstreamDecVideo *stream, uint32 *code);
+
+
+
+    PV_STATUS BitstreamCheckEndBuffer(BitstreamDecVideo *stream);
+
+    PV_STATUS PV_BitstreamShowBitsByteAlign(BitstreamDecVideo *stream, int nbits, uint32 *code);
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    PV_STATUS PV_BitstreamShowBitsByteAlignNoForceStuffing(BitstreamDecVideo *stream, int nbits, uint32 *code);
+    Bool validStuffing_h263(BitstreamDecVideo *stream);
+    PV_STATUS quickSearchH263SliceHeader(BitstreamDecVideo *stream);
+#endif
+    PV_STATUS PV_BitstreamByteAlign(BitstreamDecVideo *stream);
+    PV_STATUS BitstreamByteAlignNoForceStuffing(BitstreamDecVideo *stream);
+    Bool validStuffing(BitstreamDecVideo *stream);
+
+    PV_STATUS movePointerTo(BitstreamDecVideo *stream, int32 pos);
+    PV_STATUS PVSearchNextM4VFrame(BitstreamDecVideo *stream);
+    PV_STATUS PVSearchNextH263Frame(BitstreamDecVideo *stream);
+    PV_STATUS quickSearchVideoPacketHeader(BitstreamDecVideo *stream, int marker_length);
+
+
+    /* for error concealment & soft-decoding */
+    void PVLocateM4VFrameBoundary(BitstreamDecVideo *stream);
+    void PVSearchH263FrameBoundary(BitstreamDecVideo *stream);
+
+    PV_STATUS quickSearchMotionMarker(BitstreamDecVideo *stream);
+    PV_STATUS quickSearchDCM(BitstreamDecVideo *stream);
+    PV_STATUS quickSearchGOBHeader(BitstreamDecVideo *stream);
+    void BitstreamShowBuffer(BitstreamDecVideo *stream, int32 startbit, int32 endbit, uint8 *bitBfr);
+
+    /*  10/8/98 New prototyps. */
+    int32 getPointer(BitstreamDecVideo *stream);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus  */
+
+#endif /* _BITSTREAM_D_H_ */
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/block_idct.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/block_idct.cpp
new file mode 100644
index 0000000..a75483a
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/block_idct.cpp
@@ -0,0 +1,911 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    [input_variable_name] = [description of the input to module, its type
+                 definition, and length (when applicable)]
+
+ Local Stores/Buffers/Pointers Needed:
+    [local_store_name] = [description of the local store, its type
+                  definition, and length (when applicable)]
+    [local_buffer_name] = [description of the local buffer, its type
+                   definition, and length (when applicable)]
+    [local_ptr_name] = [description of the local pointer, its type
+                definition, and length (when applicable)]
+
+ Global Stores/Buffers/Pointers Needed:
+    [global_store_name] = [description of the global store, its type
+                   definition, and length (when applicable)]
+    [global_buffer_name] = [description of the global buffer, its type
+                definition, and length (when applicable)]
+    [global_ptr_name] = [description of the global pointer, its type
+                 definition, and length (when applicable)]
+
+ Outputs:
+    [return_variable_name] = [description of data/pointer returned
+                  by module, its type definition, and length
+                  (when applicable)]
+
+ Pointers and Buffers Modified:
+    [variable_bfr_ptr] points to the [describe where the
+      variable_bfr_ptr points to, its type definition, and length
+      (when applicable)]
+    [variable_bfr] contents are [describe the new contents of
+      variable_bfr]
+
+ Local Stores Modified:
+    [local_store_name] = [describe new contents, its type
+                  definition, and length (when applicable)]
+
+ Global Stores Modified:
+    [global_store_name] = [describe new contents, its type
+                   definition, and length (when applicable)]
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+------------------------------------------------------------------------------
+ REQUIREMENTS
+
+------------------------------------------------------------------------------
+ REFERENCES
+
+------------------------------------------------------------------------------
+ PSEUDO-CODE
+
+------------------------------------------------------------------------------
+ RESOURCES USED
+   When the code is written for a specific target processor the
+     the resources used should be documented below.
+
+ STACK USAGE: [stack count for this module] + [variable to represent
+          stack usage for each subroutine called]
+
+     where: [stack usage variable] = stack usage for [subroutine
+         name] (see [filename].ext)
+
+ DATA MEMORY USED: x words
+
+ PROGRAM MEMORY USED: x words
+
+ CLOCK CYCLES: [cycle count equation for this module] + [variable
+           used to represent cycle count for each subroutine
+           called]
+
+     where: [cycle count variable] = cycle count for [subroutine
+        name] (see [filename].ext)
+
+------------------------------------------------------------------------------
+*/
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4dec_lib.h"
+#include "idct.h"
+#include "motion_comp.h"
+
+#define OSCL_DISABLE_WARNING_CONV_POSSIBLE_LOSS_OF_DATA
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+/* private prototypes */
+static void idctrow(int16 *blk, uint8 *pred, uint8 *dst, int width);
+static void idctrow_intra(int16 *blk, PIXEL *, int width);
+static void idctcol(int16 *blk);
+
+#ifdef FAST_IDCT
+// mapping from nz_coefs to functions to be used
+
+
+// ARM4 does not allow global data when they are not constant hence
+// an array of function pointers cannot be considered as array of constants
+// (actual addresses are only known when the dll is loaded).
+// So instead of arrays of function pointers, we'll store here
+// arrays of rows or columns and then call the idct function
+// corresponding to such the row/column number:
+
+
+static void (*const idctcolVCA[10][4])(int16*) =
+{
+    {&idctcol1, &idctcol0, &idctcol0, &idctcol0},
+    {&idctcol1, &idctcol1, &idctcol0, &idctcol0},
+    {&idctcol2, &idctcol1, &idctcol0, &idctcol0},
+    {&idctcol3, &idctcol1, &idctcol0, &idctcol0},
+    {&idctcol3, &idctcol2, &idctcol0, &idctcol0},
+    {&idctcol3, &idctcol2, &idctcol1, &idctcol0},
+    {&idctcol3, &idctcol2, &idctcol1, &idctcol1},
+    {&idctcol3, &idctcol2, &idctcol2, &idctcol1},
+    {&idctcol3, &idctcol3, &idctcol2, &idctcol1},
+    {&idctcol4, &idctcol3, &idctcol2, &idctcol1}
+};
+
+
+static void (*const idctrowVCA[10])(int16*, uint8*, uint8*, int) =
+{
+    &idctrow1,
+    &idctrow2,
+    &idctrow2,
+    &idctrow2,
+    &idctrow2,
+    &idctrow3,
+    &idctrow4,
+    &idctrow4,
+    &idctrow4,
+    &idctrow4
+};
+
+
+static void (*const idctcolVCA2[16])(int16*) =
+{
+    &idctcol0, &idctcol4, &idctcol3, &idctcol4,
+    &idctcol2, &idctcol4, &idctcol3, &idctcol4,
+    &idctcol1, &idctcol4, &idctcol3, &idctcol4,
+    &idctcol2, &idctcol4, &idctcol3, &idctcol4
+};
+
+static void (*const idctrowVCA2[8])(int16*, uint8*, uint8*, int) =
+{
+    &idctrow1, &idctrow4, &idctrow3, &idctrow4,
+    &idctrow2, &idctrow4, &idctrow3, &idctrow4
+};
+
+static void (*const idctrowVCA_intra[10])(int16*, PIXEL *, int) =
+{
+    &idctrow1_intra,
+    &idctrow2_intra,
+    &idctrow2_intra,
+    &idctrow2_intra,
+    &idctrow2_intra,
+    &idctrow3_intra,
+    &idctrow4_intra,
+    &idctrow4_intra,
+    &idctrow4_intra,
+    &idctrow4_intra
+};
+
+static void (*const idctrowVCA2_intra[8])(int16*, PIXEL *, int) =
+{
+    &idctrow1_intra, &idctrow4_intra, &idctrow3_intra, &idctrow4_intra,
+    &idctrow2_intra, &idctrow4_intra, &idctrow3_intra, &idctrow4_intra
+};
+#endif
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+void MBlockIDCT(VideoDecData *video)
+{
+    Vop *currVop = video->currVop;
+    MacroBlock *mblock = video->mblock;
+    PIXEL *c_comp;
+    PIXEL *cu_comp;
+    PIXEL *cv_comp;
+    int x_pos = video->mbnum_col;
+    int y_pos = video->mbnum_row;
+    int width, width_uv;
+    int32 offset;
+    width = video->width;
+    width_uv = width >> 1;
+    offset = (int32)(y_pos << 4) * width + (x_pos << 4);
+
+    c_comp  = currVop->yChan + offset;
+    cu_comp = currVop->uChan + (offset >> 2) + (x_pos << 2);
+    cv_comp = currVop->vChan + (offset >> 2) + (x_pos << 2);
+
+    BlockIDCT_intra(mblock, c_comp, 0, width);
+    BlockIDCT_intra(mblock, c_comp + 8, 1, width);
+    BlockIDCT_intra(mblock, c_comp + (width << 3), 2, width);
+    BlockIDCT_intra(mblock, c_comp + (width << 3) + 8, 3, width);
+    BlockIDCT_intra(mblock, cu_comp, 4, width_uv);
+    BlockIDCT_intra(mblock, cv_comp, 5, width_uv);
+}
+
+
+void BlockIDCT_intra(
+    MacroBlock *mblock, PIXEL *c_comp, int comp, int width)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int16 *coeff_in = mblock->block[comp];
+#ifdef INTEGER_IDCT
+#ifdef FAST_IDCT  /* VCA IDCT using nzcoefs and bitmaps*/
+    int i, bmapr;
+    int nz_coefs = mblock->no_coeff[comp];
+    uint8 *bitmapcol = mblock->bitmapcol[comp];
+    uint8 bitmaprow = mblock->bitmaprow[comp];
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    if (nz_coefs <= 10)
+    {
+        bmapr = (nz_coefs - 1);
+
+        (*(idctcolVCA[bmapr]))(coeff_in);
+        (*(idctcolVCA[bmapr][1]))(coeff_in + 1);
+        (*(idctcolVCA[bmapr][2]))(coeff_in + 2);
+        (*(idctcolVCA[bmapr][3]))(coeff_in + 3);
+
+        (*idctrowVCA_intra[nz_coefs-1])(coeff_in, c_comp, width);
+    }
+    else
+    {
+        i = 8;
+        while (i--)
+        {
+            bmapr = (int)bitmapcol[i];
+            if (bmapr)
+            {
+                if ((bmapr&0xf) == 0)         /*  07/18/01 */
+                {
+                    (*(idctcolVCA2[bmapr>>4]))(coeff_in + i);
+                }
+                else
+                {
+                    idctcol(coeff_in + i);
+                }
+            }
+        }
+        if ((bitmapcol[4] | bitmapcol[5] | bitmapcol[6] | bitmapcol[7]) == 0)
+        {
+            bitmaprow >>= 4;
+            (*(idctrowVCA2_intra[(int)bitmaprow]))(coeff_in, c_comp, width);
+        }
+        else
+        {
+            idctrow_intra(coeff_in, c_comp, width);
+        }
+    }
+#else
+    void idct_intra(int *block, uint8 *comp, int width);
+    idct_intra(coeff_in, c_comp, width);
+#endif
+#else
+    void idctref_intra(int *block, uint8 *comp, int width);
+    idctref_intra(coeff_in, c_comp, width);
+#endif
+
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+
+/*  08/04/05, no residue, just copy from pred to output */
+void Copy_Blk_to_Vop(uint8 *dst, uint8 *pred, int width)
+{
+    /* copy 4 bytes at a time */
+    width -= 4;
+    *((uint32*)dst) = *((uint32*)pred);
+    *((uint32*)(dst += 4)) = *((uint32*)(pred += 4));
+    *((uint32*)(dst += width)) = *((uint32*)(pred += 12));
+    *((uint32*)(dst += 4)) = *((uint32*)(pred += 4));
+    *((uint32*)(dst += width)) = *((uint32*)(pred += 12));
+    *((uint32*)(dst += 4)) = *((uint32*)(pred += 4));
+    *((uint32*)(dst += width)) = *((uint32*)(pred += 12));
+    *((uint32*)(dst += 4)) = *((uint32*)(pred += 4));
+    *((uint32*)(dst += width)) = *((uint32*)(pred += 12));
+    *((uint32*)(dst += 4)) = *((uint32*)(pred += 4));
+    *((uint32*)(dst += width)) = *((uint32*)(pred += 12));
+    *((uint32*)(dst += 4)) = *((uint32*)(pred += 4));
+    *((uint32*)(dst += width)) = *((uint32*)(pred += 12));
+    *((uint32*)(dst += 4)) = *((uint32*)(pred += 4));
+    *((uint32*)(dst += width)) = *((uint32*)(pred += 12));
+    *((uint32*)(dst += 4)) = *((uint32*)(pred += 4));
+
+    return ;
+}
+
+/*  08/04/05 compute IDCT and add prediction at the end  */
+void BlockIDCT(
+    uint8 *dst,  /* destination */
+    uint8 *pred, /* prediction block, pitch 16 */
+    int16   *coeff_in,  /* DCT data, size 64 */
+    int width, /* width of dst */
+    int nz_coefs,
+    uint8 *bitmapcol,
+    uint8 bitmaprow
+)
+{
+#ifdef INTEGER_IDCT
+#ifdef FAST_IDCT  /* VCA IDCT using nzcoefs and bitmaps*/
+    int i, bmapr;
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    if (nz_coefs <= 10)
+    {
+        bmapr = (nz_coefs - 1);
+        (*(idctcolVCA[bmapr]))(coeff_in);
+        (*(idctcolVCA[bmapr][1]))(coeff_in + 1);
+        (*(idctcolVCA[bmapr][2]))(coeff_in + 2);
+        (*(idctcolVCA[bmapr][3]))(coeff_in + 3);
+
+        (*idctrowVCA[nz_coefs-1])(coeff_in, pred, dst, width);
+        return ;
+    }
+    else
+    {
+        i = 8;
+
+        while (i--)
+        {
+            bmapr = (int)bitmapcol[i];
+            if (bmapr)
+            {
+                if ((bmapr&0xf) == 0)         /*  07/18/01 */
+                {
+                    (*(idctcolVCA2[bmapr>>4]))(coeff_in + i);
+                }
+                else
+                {
+                    idctcol(coeff_in + i);
+                }
+            }
+        }
+        if ((bitmapcol[4] | bitmapcol[5] | bitmapcol[6] | bitmapcol[7]) == 0)
+        {
+            (*(idctrowVCA2[bitmaprow>>4]))(coeff_in, pred, dst, width);
+        }
+        else
+        {
+            idctrow(coeff_in, pred, dst, width);
+        }
+        return ;
+    }
+#else // FAST_IDCT
+    void idct(int *block, uint8 *pred, uint8 *dst, int width);
+    idct(coeff_in, pred, dst, width);
+    return;
+#endif // FAST_IDCT
+#else // INTEGER_IDCT
+    void idctref(int *block, uint8 *pred, uint8 *dst, int width);
+    idctref(coeff_in, pred, dst, width);
+    return;
+#endif // INTEGER_IDCT
+
+}
+/*----------------------------------------------------------------------------
+;  End Function: block_idct
+----------------------------------------------------------------------------*/
+
+
+/****************************************************************************/
+
+/*
+------------------------------------------------------------------------------
+ FUNCTION NAME: idctrow
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS FOR idctrow
+
+ Inputs:
+    [input_variable_name] = [description of the input to module, its type
+                 definition, and length (when applicable)]
+
+ Local Stores/Buffers/Pointers Needed:
+    [local_store_name] = [description of the local store, its type
+                  definition, and length (when applicable)]
+    [local_buffer_name] = [description of the local buffer, its type
+                   definition, and length (when applicable)]
+    [local_ptr_name] = [description of the local pointer, its type
+                definition, and length (when applicable)]
+
+ Global Stores/Buffers/Pointers Needed:
+    [global_store_name] = [description of the global store, its type
+                   definition, and length (when applicable)]
+    [global_buffer_name] = [description of the global buffer, its type
+                definition, and length (when applicable)]
+    [global_ptr_name] = [description of the global pointer, its type
+                 definition, and length (when applicable)]
+
+ Outputs:
+    [return_variable_name] = [description of data/pointer returned
+                  by module, its type definition, and length
+                  (when applicable)]
+
+ Pointers and Buffers Modified:
+    [variable_bfr_ptr] points to the [describe where the
+      variable_bfr_ptr points to, its type definition, and length
+      (when applicable)]
+    [variable_bfr] contents are [describe the new contents of
+      variable_bfr]
+
+ Local Stores Modified:
+    [local_store_name] = [describe new contents, its type
+                  definition, and length (when applicable)]
+
+ Global Stores Modified:
+    [global_store_name] = [describe new contents, its type
+                   definition, and length (when applicable)]
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION FOR idctrow
+
+------------------------------------------------------------------------------
+ REQUIREMENTS FOR idctrow
+
+------------------------------------------------------------------------------
+ REFERENCES FOR idctrow
+
+------------------------------------------------------------------------------
+ PSEUDO-CODE FOR idctrow
+
+------------------------------------------------------------------------------
+ RESOURCES USED FOR idctrow
+   When the code is written for a specific target processor the
+     the resources used should be documented below.
+
+ STACK USAGE: [stack count for this module] + [variable to represent
+          stack usage for each subroutine called]
+
+     where: [stack usage variable] = stack usage for [subroutine
+         name] (see [filename].ext)
+
+ DATA MEMORY USED: x words
+
+ PROGRAM MEMORY USED: x words
+
+ CLOCK CYCLES: [cycle count equation for this module] + [variable
+           used to represent cycle count for each subroutine
+           called]
+
+     where: [cycle count variable] = cycle count for [subroutine
+        name] (see [filename].ext)
+
+------------------------------------------------------------------------------
+*/
+
+/*----------------------------------------------------------------------------
+; Function Code FOR idctrow
+----------------------------------------------------------------------------*/
+void idctrow(
+    int16 *blk, uint8 *pred, uint8 *dst, int width
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* row (horizontal) IDCT
+    *
+    * 7                       pi         1 dst[k] = sum c[l] * src[l] * cos( -- *
+    * ( k + - ) * l ) l=0                      8          2
+    *
+    * where: c[0]    = 128 c[1..7] = 128*sqrt(2) */
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    width -= 4;
+    dst -= width;
+    pred -= 12;
+    blk -= 8;
+
+    while (i--)
+    {
+        x1 = (int32)blk[12] << 8;
+        blk[12] = 0;
+        x2 = blk[14];
+        blk[14] = 0;
+        x3 = blk[10];
+        blk[10] = 0;
+        x4 = blk[9];
+        blk[9] = 0;
+        x5 = blk[15];
+        blk[15] = 0;
+        x6 = blk[13];
+        blk[13] = 0;
+        x7 = blk[11];
+        blk[11] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        blk[0] = 0;   /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x8 = W7 * (x4 + x5) + 4;
+        x4 = (x8 + (W1 - W7) * x4) >> 3;
+        x5 = (x8 - (W1 + W7) * x5) >> 3;
+        x8 = W3 * (x6 + x7) + 4;
+        x6 = (x8 - (W3 - W5) * x6) >> 3;
+        x7 = (x8 - (W3 + W5) * x7) >> 3;
+
+        /* second stage */
+        x8 = x0 + x1;
+        x0 -= x1;
+        x1 = W6 * (x3 + x2) + 4;
+        x2 = (x1 - (W2 + W6) * x2) >> 3;
+        x3 = (x1 + (W2 - W6) * x3) >> 3;
+        x1 = x4 + x6;
+        x4 -= x6;
+        x6 = x5 + x7;
+        x5 -= x7;
+
+        /* third stage */
+        x7 = x8 + x3;
+        x8 -= x3;
+        x3 = x0 + x2;
+        x0 -= x2;
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x4 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        pred_word = *((uint32*)(pred += 12)); /* read 4 bytes from pred */
+
+        res = (x7 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x3 + x2) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 + x4) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x8 + x6) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += width)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred += 4)); /* read 4 bytes from pred */
+
+        res = (x8 - x6) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 - x4) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x3 - x2) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x7 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+
+void idctrow_intra(
+    int16 *blk, PIXEL *comp, int width
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8, temp;
+    int i = 8;
+    int offset = width;
+    int32 word;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* row (horizontal) IDCT
+    *
+    * 7                       pi         1 dst[k] = sum c[l] * src[l] * cos( -- *
+    * ( k + - ) * l ) l=0                      8          2
+    *
+    * where: c[0]    = 128 c[1..7] = 128*sqrt(2) */
+    while (i--)
+    {
+        x1 = (int32)blk[4] << 8;
+        blk[4] = 0;
+        x2 = blk[6];
+        blk[6] = 0;
+        x3 = blk[2];
+        blk[2] = 0;
+        x4 = blk[1];
+        blk[1] = 0;
+        x5 = blk[7];
+        blk[7] = 0;
+        x6 = blk[5];
+        blk[5] = 0;
+        x7 = blk[3];
+        blk[3] = 0;
+#ifndef FAST_IDCT
+        /* shortcut */  /* covered by idctrow1  01/9/2001 */
+        if (!(x1 | x2 | x3 | x4 | x5 | x6 | x7))
+        {
+            blk[0] = blk[1] = blk[2] = blk[3] = blk[4] = blk[5] = blk[6] = blk[7] = (blk[0] + 32) >> 6;
+            return;
+        }
+#endif
+        x0 = ((int32)blk[0] << 8) + 8192;
+        blk[0] = 0;  /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x8 = W7 * (x4 + x5) + 4;
+        x4 = (x8 + (W1 - W7) * x4) >> 3;
+        x5 = (x8 - (W1 + W7) * x5) >> 3;
+        x8 = W3 * (x6 + x7) + 4;
+        x6 = (x8 - (W3 - W5) * x6) >> 3;
+        x7 = (x8 - (W3 + W5) * x7) >> 3;
+
+        /* second stage */
+        x8 = x0 + x1;
+        x0 -= x1;
+        x1 = W6 * (x3 + x2) + 4;
+        x2 = (x1 - (W2 + W6) * x2) >> 3;
+        x3 = (x1 + (W2 - W6) * x3) >> 3;
+        x1 = x4 + x6;
+        x4 -= x6;
+        x6 = x5 + x7;
+        x5 -= x7;
+
+        /* third stage */
+        x7 = x8 + x3;
+        x8 -= x3;
+        x3 = x0 + x2;
+        x0 -= x2;
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x4 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        word = ((x7 + x1) >> 14);
+        CLIP_RESULT(word)
+
+        temp = ((x3 + x2) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 8);
+
+        temp = ((x0 + x4) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 16);
+
+        temp = ((x8 + x6) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 24);
+        *((int32*)(comp)) = word;
+
+        word = ((x8 - x6) >> 14);
+        CLIP_RESULT(word)
+
+        temp = ((x0 - x4) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 8);
+
+        temp = ((x3 - x2) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 16);
+
+        temp = ((x7 - x1) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 24);
+        *((int32*)(comp + 4)) = word;
+        comp += offset;
+
+        blk += B_SIZE;
+    }
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+
+/*----------------------------------------------------------------------------
+; End Function: idctrow
+----------------------------------------------------------------------------*/
+
+
+/****************************************************************************/
+
+/*
+------------------------------------------------------------------------------
+ FUNCTION NAME: idctcol
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS FOR idctcol
+
+ Inputs:
+    [input_variable_name] = [description of the input to module, its type
+                 definition, and length (when applicable)]
+
+ Local Stores/Buffers/Pointers Needed:
+    [local_store_name] = [description of the local store, its type
+                  definition, and length (when applicable)]
+    [local_buffer_name] = [description of the local buffer, its type
+                   definition, and length (when applicable)]
+    [local_ptr_name] = [description of the local pointer, its type
+                definition, and length (when applicable)]
+
+ Global Stores/Buffers/Pointers Needed:
+    [global_store_name] = [description of the global store, its type
+                   definition, and length (when applicable)]
+    [global_buffer_name] = [description of the global buffer, its type
+                definition, and length (when applicable)]
+    [global_ptr_name] = [description of the global pointer, its type
+                 definition, and length (when applicable)]
+
+ Outputs:
+    [return_variable_name] = [description of data/pointer returned
+                  by module, its type definition, and length
+                  (when applicable)]
+
+ Pointers and Buffers Modified:
+    [variable_bfr_ptr] points to the [describe where the
+      variable_bfr_ptr points to, its type definition, and length
+      (when applicable)]
+    [variable_bfr] contents are [describe the new contents of
+      variable_bfr]
+
+ Local Stores Modified:
+    [local_store_name] = [describe new contents, its type
+                  definition, and length (when applicable)]
+
+ Global Stores Modified:
+    [global_store_name] = [describe new contents, its type
+                   definition, and length (when applicable)]
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION FOR idctcol
+
+------------------------------------------------------------------------------
+ REQUIREMENTS FOR idctcol
+
+------------------------------------------------------------------------------
+ REFERENCES FOR idctcol
+
+------------------------------------------------------------------------------
+ PSEUDO-CODE FOR idctcol
+
+------------------------------------------------------------------------------
+ RESOURCES USED FOR idctcol
+   When the code is written for a specific target processor the
+     the resources used should be documented below.
+
+ STACK USAGE: [stack count for this module] + [variable to represent
+          stack usage for each subroutine called]
+
+     where: [stack usage variable] = stack usage for [subroutine
+         name] (see [filename].ext)
+
+ DATA MEMORY USED: x words
+
+ PROGRAM MEMORY USED: x words
+
+ CLOCK CYCLES: [cycle count equation for this module] + [variable
+           used to represent cycle count for each subroutine
+           called]
+
+     where: [cycle count variable] = cycle count for [subroutine
+        name] (see [filename].ext)
+
+------------------------------------------------------------------------------
+*/
+
+/*----------------------------------------------------------------------------
+; Function Code FOR idctcol
+----------------------------------------------------------------------------*/
+void idctcol(
+    int16 *blk
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* column (vertical) IDCT
+    *
+    * 7                         pi         1 dst[8*k] = sum c[l] * src[8*l] *
+    * cos( -- * ( k + - ) * l ) l=0                        8          2
+    *
+    * where: c[0]    = 1/1024 c[1..7] = (1/1024)*sqrt(2) */
+    x1 = (int32)blk[32] << 11;
+    x2 = blk[48];
+    x3 = blk[16];
+    x4 = blk[8];
+    x5 = blk[56];
+    x6 = blk[40];
+    x7 = blk[24];
+#ifndef FAST_IDCT
+    /* shortcut */        /* covered by idctcolumn1  01/9/2001 */
+    if (!(x1 | x2 | x3 | x4 | x5 | x6 | x7))
+    {
+        blk[0] = blk[8] = blk[16] = blk[24] = blk[32] = blk[40] = blk[48] = blk[56]
+                                              = blk[0] << 3;
+        return;
+    }
+#endif
+
+    x0 = ((int32)blk[0] << 11) + 128;
+
+    /* first stage */
+    x8 = W7 * (x4 + x5);
+    x4 = x8 + (W1 - W7) * x4;
+    x5 = x8 - (W1 + W7) * x5;
+    x8 = W3 * (x6 + x7);
+    x6 = x8 - (W3 - W5) * x6;
+    x7 = x8 - (W3 + W5) * x7;
+
+    /* second stage */
+    x8 = x0 + x1;
+    x0 -= x1;
+    x1 = W6 * (x3 + x2);
+    x2 = x1 - (W2 + W6) * x2;
+    x3 = x1 + (W2 - W6) * x3;
+    x1 = x4 + x6;
+    x4 -= x6;
+    x6 = x5 + x7;
+    x5 -= x7;
+
+    /* third stage */
+    x7 = x8 + x3;
+    x8 -= x3;
+    x3 = x0 + x2;
+    x0 -= x2;
+    x2 = (181 * (x4 + x5) + 128) >> 8;
+    x4 = (181 * (x4 - x5) + 128) >> 8;
+
+    /* fourth stage */
+    blk[0]    = (x7 + x1) >> 8;
+    blk[8] = (x3 + x2) >> 8;
+    blk[16] = (x0 + x4) >> 8;
+    blk[24] = (x8 + x6) >> 8;
+    blk[32] = (x8 - x6) >> 8;
+    blk[40] = (x0 - x4) >> 8;
+    blk[48] = (x3 - x2) >> 8;
+    blk[56] = (x7 - x1) >> 8;
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+/*----------------------------------------------------------------------------
+;  End Function: idctcol
+----------------------------------------------------------------------------*/
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/cal_dc_scaler.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/cal_dc_scaler.cpp
new file mode 100644
index 0000000..85889d3
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/cal_dc_scaler.cpp
@@ -0,0 +1,182 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    [input_variable_name] = [description of the input to module, its type
+                 definition, and length (when applicable)]
+
+ Local Stores/Buffers/Pointers Needed:
+    [local_store_name] = [description of the local store, its type
+                  definition, and length (when applicable)]
+    [local_buffer_name] = [description of the local buffer, its type
+                   definition, and length (when applicable)]
+    [local_ptr_name] = [description of the local pointer, its type
+                definition, and length (when applicable)]
+
+ Global Stores/Buffers/Pointers Needed:
+    [global_store_name] = [description of the global store, its type
+                   definition, and length (when applicable)]
+    [global_buffer_name] = [description of the global buffer, its type
+                definition, and length (when applicable)]
+    [global_ptr_name] = [description of the global pointer, its type
+                 definition, and length (when applicable)]
+
+ Outputs:
+    [return_variable_name] = [description of data/pointer returned
+                  by module, its type definition, and length
+                  (when applicable)]
+
+ Pointers and Buffers Modified:
+    [variable_bfr_ptr] points to the [describe where the
+      variable_bfr_ptr points to, its type definition, and length
+      (when applicable)]
+    [variable_bfr] contents are [describe the new contents of
+      variable_bfr]
+
+ Local Stores Modified:
+    [local_store_name] = [describe new contents, its type
+                  definition, and length (when applicable)]
+
+ Global Stores Modified:
+    [global_store_name] = [describe new contents, its type
+                   definition, and length (when applicable)]
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ This module calculates the DC quantization scale according
+ to the incoming Q and type.
+
+------------------------------------------------------------------------------
+ REQUIREMENTS
+
+ [List requirements to be satisfied by this module.]
+
+------------------------------------------------------------------------------
+ REFERENCES
+
+ [List all references used in designing this module.]
+
+------------------------------------------------------------------------------
+ PSEUDO-CODE
+
+------------------------------------------------------------------------------
+ RESOURCES USED
+   When the code is written for a specific target processor the
+     the resources used should be documented below.
+
+ STACK USAGE: [stack count for this module] + [variable to represent
+          stack usage for each subroutine called]
+
+     where: [stack usage variable] = stack usage for [subroutine
+         name] (see [filename].ext)
+
+ DATA MEMORY USED: x words
+
+ PROGRAM MEMORY USED: x words
+
+ CLOCK CYCLES: [cycle count equation for this module] + [variable
+           used to represent cycle count for each subroutine
+           called]
+
+     where: [cycle count variable] = cycle count for [subroutine
+        name] (see [filename].ext)
+
+------------------------------------------------------------------------------
+*/
+
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include    "mp4dec_lib.h"
+#include    "vlc_decode.h"
+#include    "bitstream.h"
+#include    "zigzag.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+int cal_dc_scaler(
+    int QP,
+    int type)
+{
+
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int dc_scaler;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    if (type == LUMINANCE_DC_TYPE)
+    {
+        if (QP > 0 && QP < 5) dc_scaler = 8;
+        else if (QP > 4 && QP < 9) dc_scaler = 2 * QP;
+        else if (QP > 8 && QP < 25) dc_scaler = QP + 8;
+        else dc_scaler = 2 * QP - 16;
+    }
+    else /* if (type == CHROMINANCE_DC_TYPE), there is no other types.  */
+    {
+        if (QP > 0 && QP < 5) dc_scaler = 8;
+        else if (QP > 4 && QP < 25) dc_scaler = (QP + 13) >> 1;
+        else dc_scaler = QP - 6;
+    }
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return dc_scaler;
+}
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/chv_filter.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/chv_filter.cpp
new file mode 100644
index 0000000..6593b48
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/chv_filter.cpp
@@ -0,0 +1,654 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    [input_variable_name] = [description of the input to module, its type
+                 definition, and length (when applicable)]
+
+ Local Stores/Buffers/Pointers Needed:
+    [local_store_name] = [description of the local store, its type
+                  definition, and length (when applicable)]
+    [local_buffer_name] = [description of the local buffer, its type
+                   definition, and length (when applicable)]
+    [local_ptr_name] = [description of the local pointer, its type
+                definition, and length (when applicable)]
+
+ Global Stores/Buffers/Pointers Needed:
+    [global_store_name] = [description of the global store, its type
+                   definition, and length (when applicable)]
+    [global_buffer_name] = [description of the global buffer, its type
+                definition, and length (when applicable)]
+    [global_ptr_name] = [description of the global pointer, its type
+                 definition, and length (when applicable)]
+
+ Outputs:
+    [return_variable_name] = [description of data/pointer returned
+                  by module, its type definition, and length
+                  (when applicable)]
+
+ Pointers and Buffers Modified:
+    [variable_bfr_ptr] points to the [describe where the
+      variable_bfr_ptr points to, its type definition, and length
+      (when applicable)]
+    [variable_bfr] contents are [describe the new contents of
+      variable_bfr]
+
+ Local Stores Modified:
+    [local_store_name] = [describe new contents, its type
+                  definition, and length (when applicable)]
+
+ Global Stores Modified:
+    [global_store_name] = [describe new contents, its type
+                   definition, and length (when applicable)]
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+   For fast Deblock filtering
+   Newer version (macroblock based processing)
+
+------------------------------------------------------------------------------
+ REQUIREMENTS
+
+ [List requirements to be satisfied by this module.]
+
+------------------------------------------------------------------------------
+ REFERENCES
+
+ [List all references used in designing this module.]
+
+------------------------------------------------------------------------------
+ PSEUDO-CODE
+
+------------------------------------------------------------------------------
+ RESOURCES USED
+   When the code is written for a specific target processor the
+     the resources used should be documented below.
+
+ STACK USAGE: [stack count for this module] + [variable to represent
+          stack usage for each subroutine called]
+
+     where: [stack usage variable] = stack usage for [subroutine
+         name] (see [filename].ext)
+
+ DATA MEMORY USED: x words
+
+ PROGRAM MEMORY USED: x words
+
+ CLOCK CYCLES: [cycle count equation for this module] + [variable
+           used to represent cycle count for each subroutine
+           called]
+
+     where: [cycle count variable] = cycle count for [subroutine
+        name] (see [filename].ext)
+
+------------------------------------------------------------------------------
+*/
+
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include    "mp4dec_lib.h"
+#include    "post_proc.h"
+
+#define OSCL_DISABLE_WARNING_CONV_POSSIBLE_LOSS_OF_DATA
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+//#define FILTER_LEN_8
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+
+----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+#ifdef PV_POSTPROC_ON
+
+/*************************************************************************
+    Function prototype : void CombinedHorzVertFilter(   uint8 *rec,
+                                                        int width,
+                                                        int height,
+                                                        int *QP_store,
+                                                        int chr,
+                                                        uint8 *pp_mod)
+    Parameters  :
+        rec     :   pointer to the decoded frame buffer.
+        width   :   width of decoded frame.
+        height  :   height of decoded frame
+        QP_store:   pointer to the array of QP corresponding to the decoded frame.
+                    It had only one value for each MB.
+        chr     :   luma or color indication
+                    == 0 luma
+                    == 1 color
+        pp_mod  :   The semphore used for deblocking
+
+    Remark      :   The function do the deblocking on decoded frames.
+                    First based on the semaphore info., it is divided into hard and soft filtering.
+                    To differentiate real and fake edge, it then check the difference with QP to
+                    decide whether to do the filtering or not.
+
+*************************************************************************/
+
+
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+void CombinedHorzVertFilter(
+    uint8 *rec,
+    int width,
+    int height,
+    int16 *QP_store,
+    int chr,
+    uint8 *pp_mod)
+{
+
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int br, bc, mbr, mbc;
+    int QP = 1;
+    uint8 *ptr, *ptr_e;
+    int pp_w, pp_h;
+    int brwidth;
+
+    int jVal0, jVal1, jVal2;
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    pp_w = (width >> 3);
+    pp_h = (height >> 3);
+
+    for (mbr = 0; mbr < pp_h; mbr += 2)         /* row of blocks */
+    {
+        brwidth = mbr * pp_w;               /* number of blocks above current block row */
+        for (mbc = 0; mbc < pp_w; mbc += 2)     /* col of blocks */
+        {
+            if (!chr)
+                QP = QP_store[(brwidth>>2) + (mbc>>1)]; /* QP is per MB based value */
+
+            /********* for each block **************/
+            /****************** Horiz. Filtering ********************/
+            for (br = mbr + 1; br < mbr + 3; br++)  /* 2x2 blocks */
+            {
+                brwidth += pp_w;                    /* number of blocks above & left current block row */
+                /* the profile on ARM920T shows separate these two boundary check is faster than combine them */
+                if (br < pp_h)                  /* boundary : don't do it on the lowest row block */
+                    for (bc = mbc; bc < mbc + 2; bc++)
+                    {
+                        /****** check boundary for deblocking ************/
+                        if (bc < pp_w)              /* boundary : don't do it on the most right col block */
+                        {
+                            ptr = rec + (brwidth << 6) + (bc << 3);
+                            jVal0 = brwidth + bc;
+                            if (chr)    QP = QP_store[jVal0];
+
+                            ptr_e = ptr + 8;        /* pointer to where the loop ends */
+
+                            if (((pp_mod[jVal0]&0x02)) && ((pp_mod[jVal0-pp_w]&0x02)))
+                            {
+                                /* Horiz Hard filter */
+                                do
+                                {
+                                    jVal0 = *(ptr - width);     /* C */
+                                    jVal1 = *ptr;               /* D */
+                                    jVal2 = jVal1 - jVal0;
+
+                                    if (((jVal2 > 0) && (jVal2 < (QP << 1)))
+                                            || ((jVal2 < 0) && (jVal2 > -(QP << 1)))) /* (D-C) compared with 2QP */
+                                    {
+                                        /* differentiate between real and fake edge */
+                                        jVal0 = ((jVal0 + jVal1) >> 1);     /* (D+C)/2 */
+                                        *(ptr - width) = (uint8)(jVal0);    /*  C */
+                                        *ptr = (uint8)(jVal0);          /*  D */
+
+                                        jVal0 = *(ptr - (width << 1));      /* B */
+                                        jVal1 = *(ptr + width);         /* E */
+                                        jVal2 = jVal1 - jVal0;      /* E-B */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal0 += ((jVal2 + 3) >> 2);
+                                            jVal1 -= ((jVal2 + 3) >> 2);
+                                            *(ptr - (width << 1)) = (uint8)jVal0;       /*  store B */
+                                            *(ptr + width) = (uint8)jVal1;          /* store E */
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal0 -= ((3 - jVal2) >> 2);
+                                            jVal1 += ((3 - jVal2) >> 2);
+                                            *(ptr - (width << 1)) = (uint8)jVal0;       /*  store B */
+                                            *(ptr + width) = (uint8)jVal1;          /* store E */
+                                        }
+
+                                        jVal0 = *(ptr - (width << 1) - width);  /* A */
+                                        jVal1 = *(ptr + (width << 1));      /* F */
+                                        jVal2 = jVal1 - jVal0;              /* (F-A) */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal0 += ((jVal2 + 7) >> 3);
+                                            jVal1 -= ((jVal2 + 7) >> 3);
+                                            *(ptr - (width << 1) - width) = (uint8)(jVal0);
+                                            *(ptr + (width << 1)) = (uint8)(jVal1);
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal0 -= ((7 - jVal2) >> 3);
+                                            jVal1 += ((7 - jVal2) >> 3);
+                                            *(ptr - (width << 1) - width) = (uint8)(jVal0);
+                                            *(ptr + (width << 1)) = (uint8)(jVal1);
+                                        }
+                                    }/* a3_0 > 2QP */
+                                }
+                                while (++ptr < ptr_e);
+                            }
+                            else   /* Horiz soft filter*/
+                            {
+                                do
+                                {
+                                    jVal0 = *(ptr - width); /* B */
+                                    jVal1 = *ptr;           /* C */
+                                    jVal2 = jVal1 - jVal0;  /* C-B */
+
+                                    if (((jVal2 > 0) && (jVal2 < (QP)))
+                                            || ((jVal2 < 0) && (jVal2 > -(QP)))) /* (C-B) compared with QP */
+                                    {
+
+                                        jVal0 = ((jVal0 + jVal1) >> 1);     /* (B+C)/2 cannot overflow; ceil() */
+                                        *(ptr - width) = (uint8)(jVal0);    /* B = (B+C)/2 */
+                                        *ptr = (uint8)jVal0;            /* C = (B+C)/2 */
+
+                                        jVal0 = *(ptr - (width << 1));      /* A */
+                                        jVal1 = *(ptr + width);         /* D */
+                                        jVal2 = jVal1 - jVal0;          /* D-A */
+
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal1 -= ((jVal2 + 7) >> 3);
+                                            jVal0 += ((jVal2 + 7) >> 3);
+                                            *(ptr - (width << 1)) = (uint8)jVal0;       /* A */
+                                            *(ptr + width) = (uint8)jVal1;          /* D */
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal1 += ((7 - jVal2) >> 3);
+                                            jVal0 -= ((7 - jVal2) >> 3);
+                                            *(ptr - (width << 1)) = (uint8)jVal0;       /* A */
+                                            *(ptr + width) = (uint8)jVal1;          /* D */
+                                        }
+                                    }
+                                }
+                                while (++ptr < ptr_e);
+                            } /* Soft filter*/
+                        }/* boundary checking*/
+                    }/*bc*/
+            }/*br*/
+            brwidth -= (pp_w << 1);
+            /****************** Vert. Filtering ********************/
+            for (br = mbr; br < mbr + 2; br++)
+            {
+                if (br < pp_h)
+                    for (bc = mbc + 1; bc < mbc + 3; bc++)
+                    {
+                        /****** check boundary for deblocking ************/
+                        if (bc < pp_w)
+                        {
+                            ptr = rec + (brwidth << 6) + (bc << 3);
+                            jVal0 = brwidth + bc;
+                            if (chr)    QP = QP_store[jVal0];
+
+                            ptr_e = ptr + (width << 3);
+
+                            if (((pp_mod[jVal0-1]&0x01)) && ((pp_mod[jVal0]&0x01)))
+                            {
+                                /* Vert Hard filter */
+                                do
+                                {
+                                    jVal1 = *ptr;       /* D */
+                                    jVal0 = *(ptr - 1); /* C */
+                                    jVal2 = jVal1 - jVal0;  /* D-C */
+
+                                    if (((jVal2 > 0) && (jVal2 < (QP << 1)))
+                                            || ((jVal2 < 0) && (jVal2 > -(QP << 1))))
+                                    {
+                                        jVal1 = (jVal0 + jVal1) >> 1;   /* (C+D)/2 */
+                                        *ptr        =   jVal1;
+                                        *(ptr - 1)  =   jVal1;
+
+                                        jVal1 = *(ptr + 1);     /* E */
+                                        jVal0 = *(ptr - 2);     /* B */
+                                        jVal2 = jVal1 - jVal0;      /* E-B */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal1 -= ((jVal2 + 3) >> 2);        /* E = E -(E-B)/4 */
+                                            jVal0 += ((jVal2 + 3) >> 2);        /* B = B +(E-B)/4 */
+                                            *(ptr + 1) = jVal1;
+                                            *(ptr - 2) = jVal0;
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal1 += ((3 - jVal2) >> 2);        /* E = E -(E-B)/4 */
+                                            jVal0 -= ((3 - jVal2) >> 2);        /* B = B +(E-B)/4 */
+                                            *(ptr + 1) = jVal1;
+                                            *(ptr - 2) = jVal0;
+                                        }
+
+                                        jVal1 = *(ptr + 2);     /* F */
+                                        jVal0 = *(ptr - 3);     /* A */
+
+                                        jVal2 = jVal1 - jVal0;          /* (F-A) */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal1 -= ((jVal2 + 7) >> 3);    /* F -= (F-A)/8 */
+                                            jVal0 += ((jVal2 + 7) >> 3);    /* A += (F-A)/8 */
+                                            *(ptr + 2) = jVal1;
+                                            *(ptr - 3) = jVal0;
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal1 -= ((jVal2 - 7) >> 3);    /* F -= (F-A)/8 */
+                                            jVal0 += ((jVal2 - 7) >> 3);    /* A += (F-A)/8 */
+                                            *(ptr + 2) = jVal1;
+                                            *(ptr - 3) = jVal0;
+                                        }
+                                    }   /* end of ver hard filetering */
+                                }
+                                while ((ptr += width) < ptr_e);
+                            }
+                            else   /* Vert soft filter*/
+                            {
+                                do
+                                {
+                                    jVal1 = *ptr;               /* C */
+                                    jVal0 = *(ptr - 1);         /* B */
+                                    jVal2 = jVal1 - jVal0;
+
+                                    if (((jVal2 > 0) && (jVal2 < (QP)))
+                                            || ((jVal2 < 0) && (jVal2 > -(QP))))
+                                    {
+
+                                        jVal1 = (jVal0 + jVal1 + 1) >> 1;
+                                        *ptr = jVal1;           /* C */
+                                        *(ptr - 1) = jVal1;     /* B */
+
+                                        jVal1 = *(ptr + 1);     /* D */
+                                        jVal0 = *(ptr - 2);     /* A */
+                                        jVal2 = (jVal1 - jVal0);        /* D- A */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal1 -= (((jVal2) + 7) >> 3);      /* D -= (D-A)/8 */
+                                            jVal0 += (((jVal2) + 7) >> 3);      /* A += (D-A)/8 */
+                                            *(ptr + 1) = jVal1;
+                                            *(ptr - 2) = jVal0;
+
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal1 += ((7 - (jVal2)) >> 3);      /* D -= (D-A)/8 */
+                                            jVal0 -= ((7 - (jVal2)) >> 3);      /* A += (D-A)/8 */
+                                            *(ptr + 1) = jVal1;
+                                            *(ptr - 2) = jVal0;
+                                        }
+                                    }
+                                }
+                                while ((ptr += width) < ptr_e);
+                            } /* Soft filter*/
+                        } /* boundary*/
+                    } /*bc*/
+                brwidth += pp_w;
+            }/*br*/
+            brwidth -= (pp_w << 1);
+        }/*mbc*/
+        brwidth += (pp_w << 1);
+    }/*mbr*/
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+void CombinedHorzVertFilter_NoSoftDeblocking(
+    uint8 *rec,
+    int width,
+    int height,
+    int16 *QP_store,
+    int chr,
+    uint8 *pp_mod)
+{
+
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int br, bc, mbr, mbc;
+    int QP = 1;
+    uint8 *ptr, *ptr_e;
+    int pp_w, pp_h;
+    int brwidth;
+
+    int jVal0, jVal1, jVal2;
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    pp_w = (width >> 3);
+    pp_h = (height >> 3);
+
+    for (mbr = 0; mbr < pp_h; mbr += 2)         /* row of blocks */
+    {
+        brwidth = mbr * pp_w;               /* number of blocks above current block row */
+        for (mbc = 0; mbc < pp_w; mbc += 2)     /* col of blocks */
+        {
+            if (!chr)
+                QP = QP_store[(brwidth>>2) + (mbc>>1)]; /* QP is per MB based value */
+
+            /********* for each block **************/
+            /****************** Horiz. Filtering ********************/
+            for (br = mbr + 1; br < mbr + 3; br++)  /* 2x2 blocks */
+            {
+                brwidth += pp_w;                    /* number of blocks above & left current block row */
+                /* the profile on ARM920T shows separate these two boundary check is faster than combine them */
+                if (br < pp_h)                  /* boundary : don't do it on the lowest row block */
+                    for (bc = mbc; bc < mbc + 2; bc++)
+                    {
+                        /****** check boundary for deblocking ************/
+                        if (bc < pp_w)              /* boundary : don't do it on the most right col block */
+                        {
+                            ptr = rec + (brwidth << 6) + (bc << 3);
+                            jVal0 = brwidth + bc;
+                            if (chr)    QP = QP_store[jVal0];
+
+                            ptr_e = ptr + 8;        /* pointer to where the loop ends */
+
+                            if (((pp_mod[jVal0]&0x02)) && ((pp_mod[jVal0-pp_w]&0x02)))
+                            {
+                                /* Horiz Hard filter */
+                                do
+                                {
+                                    jVal0 = *(ptr - width);     /* C */
+                                    jVal1 = *ptr;               /* D */
+                                    jVal2 = jVal1 - jVal0;
+
+                                    if (((jVal2 > 0) && (jVal2 < (QP << 1)))
+                                            || ((jVal2 < 0) && (jVal2 > -(QP << 1)))) /* (D-C) compared with 2QP */
+                                    {
+                                        /* differentiate between real and fake edge */
+                                        jVal0 = ((jVal0 + jVal1) >> 1);     /* (D+C)/2 */
+                                        *(ptr - width) = (uint8)(jVal0);    /*  C */
+                                        *ptr = (uint8)(jVal0);          /*  D */
+
+                                        jVal0 = *(ptr - (width << 1));      /* B */
+                                        jVal1 = *(ptr + width);         /* E */
+                                        jVal2 = jVal1 - jVal0;      /* E-B */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal0 += ((jVal2 + 3) >> 2);
+                                            jVal1 -= ((jVal2 + 3) >> 2);
+                                            *(ptr - (width << 1)) = (uint8)jVal0;       /*  store B */
+                                            *(ptr + width) = (uint8)jVal1;          /* store E */
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal0 -= ((3 - jVal2) >> 2);
+                                            jVal1 += ((3 - jVal2) >> 2);
+                                            *(ptr - (width << 1)) = (uint8)jVal0;       /*  store B */
+                                            *(ptr + width) = (uint8)jVal1;          /* store E */
+                                        }
+
+                                        jVal0 = *(ptr - (width << 1) - width);  /* A */
+                                        jVal1 = *(ptr + (width << 1));      /* F */
+                                        jVal2 = jVal1 - jVal0;              /* (F-A) */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal0 += ((jVal2 + 7) >> 3);
+                                            jVal1 -= ((jVal2 + 7) >> 3);
+                                            *(ptr - (width << 1) - width) = (uint8)(jVal0);
+                                            *(ptr + (width << 1)) = (uint8)(jVal1);
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal0 -= ((7 - jVal2) >> 3);
+                                            jVal1 += ((7 - jVal2) >> 3);
+                                            *(ptr - (width << 1) - width) = (uint8)(jVal0);
+                                            *(ptr + (width << 1)) = (uint8)(jVal1);
+                                        }
+                                    }/* a3_0 > 2QP */
+                                }
+                                while (++ptr < ptr_e);
+                            }
+
+                        }/* boundary checking*/
+                    }/*bc*/
+            }/*br*/
+            brwidth -= (pp_w << 1);
+            /****************** Vert. Filtering ********************/
+            for (br = mbr; br < mbr + 2; br++)
+            {
+                if (br < pp_h)
+                    for (bc = mbc + 1; bc < mbc + 3; bc++)
+                    {
+                        /****** check boundary for deblocking ************/
+                        if (bc < pp_w)
+                        {
+                            ptr = rec + (brwidth << 6) + (bc << 3);
+                            jVal0 = brwidth + bc;
+                            if (chr)    QP = QP_store[jVal0];
+
+                            ptr_e = ptr + (width << 3);
+
+                            if (((pp_mod[jVal0-1]&0x01)) && ((pp_mod[jVal0]&0x01)))
+                            {
+                                /* Vert Hard filter */
+                                do
+                                {
+                                    jVal1 = *ptr;       /* D */
+                                    jVal0 = *(ptr - 1); /* C */
+                                    jVal2 = jVal1 - jVal0;  /* D-C */
+
+                                    if (((jVal2 > 0) && (jVal2 < (QP << 1)))
+                                            || ((jVal2 < 0) && (jVal2 > -(QP << 1))))
+                                    {
+                                        jVal1 = (jVal0 + jVal1) >> 1;   /* (C+D)/2 */
+                                        *ptr        =   jVal1;
+                                        *(ptr - 1)  =   jVal1;
+
+                                        jVal1 = *(ptr + 1);     /* E */
+                                        jVal0 = *(ptr - 2);     /* B */
+                                        jVal2 = jVal1 - jVal0;      /* E-B */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal1 -= ((jVal2 + 3) >> 2);        /* E = E -(E-B)/4 */
+                                            jVal0 += ((jVal2 + 3) >> 2);        /* B = B +(E-B)/4 */
+                                            *(ptr + 1) = jVal1;
+                                            *(ptr - 2) = jVal0;
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal1 += ((3 - jVal2) >> 2);        /* E = E -(E-B)/4 */
+                                            jVal0 -= ((3 - jVal2) >> 2);        /* B = B +(E-B)/4 */
+                                            *(ptr + 1) = jVal1;
+                                            *(ptr - 2) = jVal0;
+                                        }
+
+                                        jVal1 = *(ptr + 2);     /* F */
+                                        jVal0 = *(ptr - 3);     /* A */
+
+                                        jVal2 = jVal1 - jVal0;          /* (F-A) */
+
+                                        if (jVal2 > 0)
+                                        {
+                                            jVal1 -= ((jVal2 + 7) >> 3);    /* F -= (F-A)/8 */
+                                            jVal0 += ((jVal2 + 7) >> 3);    /* A += (F-A)/8 */
+                                            *(ptr + 2) = jVal1;
+                                            *(ptr - 3) = jVal0;
+                                        }
+                                        else if (jVal2)
+                                        {
+                                            jVal1 -= ((jVal2 - 7) >> 3);    /* F -= (F-A)/8 */
+                                            jVal0 += ((jVal2 - 7) >> 3);    /* A += (F-A)/8 */
+                                            *(ptr + 2) = jVal1;
+                                            *(ptr - 3) = jVal0;
+                                        }
+                                    }   /* end of ver hard filetering */
+                                }
+                                while ((ptr += width) < ptr_e);
+                            }
+
+                        } /* boundary*/
+                    } /*bc*/
+                brwidth += pp_w;
+            }/*br*/
+            brwidth -= (pp_w << 1);
+        }/*mbc*/
+        brwidth += (pp_w << 1);
+    }/*mbr*/
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/chvr_filter.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/chvr_filter.cpp
new file mode 100644
index 0000000..795cf71
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/chvr_filter.cpp
@@ -0,0 +1,565 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include    "mp4dec_lib.h"
+#include    "post_proc.h"
+
+#ifdef PV_POSTPROC_ON
+
+void CombinedHorzVertRingFilter(
+    uint8 *rec,
+    int width,
+    int height,
+    int16 *QP_store,
+    int chr,
+    uint8 *pp_mod)
+{
+
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int index, counter;
+    int br, bc, incr, mbr, mbc;
+    int QP = 1;
+    int v[5];
+    uint8 *ptr, *ptr_c, *ptr_n;
+    int w1, w2, w3, w4;
+    int pp_w, pp_h, brwidth;
+    int sum, delta;
+    int a3_0, a3_1, a3_2, A3_0;
+    /* for Deringing Threshold approach (MPEG4)*/
+    int max_diff, thres, v0, h0, min_blk, max_blk;
+    int cnthflag;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* Calculate the width and height of the area in blocks (divide by 8) */
+    pp_w = (width >> 3);
+    pp_h = (height >> 3);
+
+    /* Set up various values needed for updating pointers into rec */
+    w1 = width;             /* Offset to next row in pixels */
+    w2 = width << 1;        /* Offset to two rows in pixels */
+    w3 = w1 + w2;           /* Offset to three rows in pixels */
+    w4 = w2 << 1;           /* Offset to four rows in pixels */
+    incr = width - BLKSIZE; /* Offset to next row after processing block */
+
+    /* Work through the area hortizontally by two rows per step */
+    for (mbr = 0; mbr < pp_h; mbr += 2)
+    {
+        /* brwidth contains the block number of the leftmost block
+         * of the current row */
+        brwidth = mbr * pp_w;
+
+        /* Work through the area vertically by two columns per step */
+        for (mbc = 0; mbc < pp_w; mbc += 2)
+        {
+            /* if the data is luminance info, get the correct
+                    * quantization paramenter. One parameter per macroblock */
+            if (!chr)
+            {
+                /* brwidth/4 is the macroblock number and mbc/2 is the macroblock col number*/
+                QP = QP_store[(brwidth>>2) + (mbc>>1)];
+            }
+
+            /****************** Horiz. Filtering ********************/
+            /* Process four blocks for the filtering        */
+            /********************************************************/
+            /* Loop over two rows of blocks */
+            for (br = mbr + 1; br < mbr + 3; br++)    /* br is the row counter in blocks */
+            {
+                /* Set brwidth to the first (leftmost) block number of the next row */
+                /* brwidth is used as an index when counting blocks */
+                brwidth += pp_w;
+
+                /* Loop over two columns of blocks in the row */
+                for (bc = mbc; bc < mbc + 2; bc++)    /* bc is the column counter in blocks */
+                {
+                    /****** check boundary for deblocking ************/
+                    /* Execute if the row and column counters are within the area */
+                    if (br < pp_h && bc < pp_w)
+                    {
+                        /* Set the ptr to the first pixel of the first block of the second row
+                        * brwidth * 64 is the pixel row offset
+                        * bc * 8 is the pixel column offset */
+                        ptr = rec + (brwidth << 6) + (bc << 3);
+
+                        /* Set the index to the current block of the second row counting in blocks */
+                        index = brwidth + bc;
+
+                        /* if the data is chrominance info, get the correct
+                         * quantization paramenter. One parameter per block. */
+                        if (chr)
+                        {
+                            QP = QP_store[index];
+                        }
+
+                        /* Execute hard horizontal filter if semaphore for horizontal deblocking
+                          * is set for the current block and block immediately above it */
+                        if (((pp_mod[index]&0x02) != 0) && ((pp_mod[index-pp_w]&0x02) != 0))
+                        {   /* Hard filter */
+
+                            /* Set HorzHflag (bit 4) in the pp_mod location */
+                            pp_mod[index-pp_w] |= 0x10; /*  4/26/00 reuse pp_mod for HorzHflag*/
+
+                            /* Filter across the 8 pixels of the block */
+                            for (index = BLKSIZE; index > 0; index--)
+                            {
+                                /* Difference between the current pixel and the pixel above it */
+                                a3_0 = *ptr - *(ptr - w1);
+
+                                /* if the magnitude of the difference is greater than the KThH threshold
+                                 * and within the quantization parameter, apply hard filter */
+                                if ((a3_0 > KThH || a3_0 < -KThH) && a3_0<QP && a3_0> -QP)
+                                {
+                                    ptr_c = ptr - w3;   /* Points to pixel three rows above */
+                                    ptr_n = ptr + w1;   /* Points to pixel one row below */
+                                    v[0] = (int)(*(ptr_c - w3));
+                                    v[1] = (int)(*(ptr_c - w2));
+                                    v[2] = (int)(*(ptr_c - w1));
+                                    v[3] = (int)(*ptr_c);
+                                    v[4] = (int)(*(ptr_c + w1));
+
+                                    sum = v[0]
+                                          + v[1]
+                                          + v[2]
+                                          + *ptr_c
+                                          + v[4]
+                                          + (*(ptr_c + w2))
+                                          + (*(ptr_c + w3));  /* Current pixel */
+
+                                    delta = (sum + *ptr_c + 4) >> 3;   /* Average pixel values with rounding */
+                                    *(ptr_c) = (uint8) delta;
+
+                                    /* Move pointer down one row of pixels (points to pixel two rows
+                                     * above current pixel) */
+                                    ptr_c += w1;
+
+                                    for (counter = 0; counter < 5; counter++)
+                                    {
+                                        /* Subtract off highest pixel and add in pixel below */
+                                        sum = sum - v[counter] + *ptr_n;
+                                        /* Average the pixel values with rounding */
+                                        delta = (sum + *ptr_c + 4) >> 3;
+                                        *ptr_c = (uint8)(delta);
+
+                                        /* Increment pointers to next pixel row */
+                                        ptr_c += w1;
+                                        ptr_n += w1;
+                                    }
+                                }
+                                /* Increment pointer to next pixel */
+                                ++ptr;
+                            } /* index*/
+                        }
+                        else
+                        { /* soft filter*/
+
+                            /* Clear HorzHflag (bit 4) in the pp_mod location */
+                            pp_mod[index-pp_w] &= 0xef; /* reset 1110,1111 */
+
+                            for (index = BLKSIZE; index > 0; index--)
+                            {
+                                /* Difference between the current pixel and the pixel above it */
+                                a3_0 = *(ptr) - *(ptr - w1);
+
+                                /* if the magnitude of the difference is greater than the KTh threshold,
+                                 * apply soft filter */
+                                if ((a3_0 > KTh || a3_0 < -KTh))
+                                {
+
+                                    /* Sum of weighted differences */
+                                    a3_0 += ((*(ptr - w2) - *(ptr + w1)) << 1) + (a3_0 << 2);
+
+                                    /* Check if sum is less than the quantization parameter */
+                                    if (PV_ABS(a3_0) < (QP << 3))
+                                    {
+                                        a3_1 = *(ptr - w2) - *(ptr - w3);
+                                        a3_1 += ((*(ptr - w4) - *(ptr - w1)) << 1) + (a3_1 << 2);
+
+                                        a3_2  = *(ptr + w2) - *(ptr + w1);
+                                        a3_2 += ((*(ptr) - *(ptr + w3)) << 1) + (a3_2 << 2);
+
+                                        A3_0 = PV_ABS(a3_0) - PV_MIN(PV_ABS(a3_1), PV_ABS(a3_2));
+
+                                        if (A3_0 > 0)
+                                        {
+                                            A3_0 += A3_0 << 2;
+                                            A3_0 = (A3_0 + 32) >> 6;
+                                            if (a3_0 > 0)
+                                            {
+                                                A3_0 = -A3_0;
+                                            }
+
+                                            delta = (*(ptr - w1) - *(ptr)) >> 1;
+                                            if (delta >= 0)
+                                            {
+                                                if (delta >= A3_0)
+                                                {
+                                                    delta = PV_MAX(A3_0, 0);
+                                                }
+                                            }
+                                            else
+                                            {
+                                                if (A3_0 > 0)
+                                                {
+                                                    delta = 0;
+                                                }
+                                                else
+                                                {
+                                                    delta = PV_MAX(A3_0, delta);
+                                                }
+                                            }
+
+                                            *(ptr - w1) = (uint8)(*(ptr - w1) - delta);
+                                            *(ptr) = (uint8)(*(ptr) + delta);
+                                        }
+                                    } /*threshold*/
+                                }
+                                /* Increment pointer to next pixel */
+                                ++ptr;
+                            } /*index*/
+                        } /* Soft filter*/
+                    }/* boundary checking*/
+                }/*bc*/
+            }/*br*/
+            brwidth -= (pp_w << 1);
+
+
+            /****************** Vert. Filtering *********************/
+            /* Process four blocks for the filtering        */
+            /********************************************************/
+            /* Loop over two rows of blocks */
+            for (br = mbr; br < mbr + 2; br++)      /* br is the row counter in blocks */
+            {
+                for (bc = mbc + 1; bc < mbc + 3; bc++)  /* bc is the column counter in blocks */
+                {
+                    /****** check boundary for deblocking ************/
+                    /* Execute if the row and column counters are within the area */
+                    if (br < pp_h && bc < pp_w)
+                    {
+                        /* Set the ptr to the first pixel of the first block of the second row
+                        * brwidth * 64 is the pixel row offset
+                        * bc * 8 is the pixel column offset */
+                        ptr = rec + (brwidth << 6) + (bc << 3);
+
+                        /* Set the index to the current block of the second row counting in blocks */
+                        index = brwidth + bc;
+
+                        /* if the data is chrominance info, get the correct
+                         * quantization paramenter. One parameter per block. */
+                        if (chr)
+                        {
+                            QP = QP_store[index];
+                        }
+
+                        /* Execute hard vertical filter if semaphore for vertical deblocking
+                          * is set for the current block and block immediately left of it */
+                        if (((pp_mod[index-1]&0x01) != 0) && ((pp_mod[index]&0x01) != 0))
+                        {   /* Hard filter */
+
+                            /* Set VertHflag (bit 5) in the pp_mod location of previous block*/
+                            pp_mod[index-1] |= 0x20; /*  4/26/00 reuse pp_mod for VertHflag*/
+
+                            /* Filter across the 8 pixels of the block */
+                            for (index = BLKSIZE; index > 0; index--)
+                            {
+                                /* Difference between the current pixel
+                                * and the pixel to left of it */
+                                a3_0 = *ptr - *(ptr - 1);
+
+                                /* if the magnitude of the difference is greater than the KThH threshold
+                                 * and within the quantization parameter, apply hard filter */
+                                if ((a3_0 > KThH || a3_0 < -KThH) && a3_0<QP && a3_0> -QP)
+                                {
+                                    ptr_c = ptr - 3;
+                                    ptr_n = ptr + 1;
+                                    v[0] = (int)(*(ptr_c - 3));
+                                    v[1] = (int)(*(ptr_c - 2));
+                                    v[2] = (int)(*(ptr_c - 1));
+                                    v[3] = (int)(*ptr_c);
+                                    v[4] = (int)(*(ptr_c + 1));
+
+                                    sum = v[0]
+                                          + v[1]
+                                          + v[2]
+                                          + *ptr_c
+                                          + v[4]
+                                          + (*(ptr_c + 2))
+                                          + (*(ptr_c + 3));
+
+                                    delta = (sum + *ptr_c + 4) >> 3;
+                                    *(ptr_c) = (uint8) delta;
+
+                                    /* Move pointer down one pixel to the right */
+                                    ptr_c += 1;
+                                    for (counter = 0; counter < 5; counter++)
+                                    {
+                                        /* Subtract off highest pixel and add in pixel below */
+                                        sum = sum - v[counter] + *ptr_n;
+                                        /* Average the pixel values with rounding */
+                                        delta = (sum + *ptr_c + 4) >> 3;
+                                        *ptr_c = (uint8)(delta);
+
+                                        /* Increment pointers to next pixel */
+                                        ptr_c += 1;
+                                        ptr_n += 1;
+                                    }
+                                }
+                                /* Increment pointers to next pixel row */
+                                ptr += w1;
+                            } /* index*/
+                        }
+                        else
+                        { /* soft filter*/
+
+                            /* Clear VertHflag (bit 5) in the pp_mod location */
+                            pp_mod[index-1] &= 0xdf; /* reset 1101,1111 */
+                            for (index = BLKSIZE; index > 0; index--)
+                            {
+                                /* Difference between the current pixel and the pixel above it */
+                                a3_0 = *(ptr) - *(ptr - 1);
+
+                                /* if the magnitude of the difference is greater than the KTh threshold,
+                                 * apply soft filter */
+                                if ((a3_0 > KTh || a3_0 < -KTh))
+                                {
+
+                                    /* Sum of weighted differences */
+                                    a3_0 += ((*(ptr - 2) - *(ptr + 1)) << 1) + (a3_0 << 2);
+
+                                    /* Check if sum is less than the quantization parameter */
+                                    if (PV_ABS(a3_0) < (QP << 3))
+                                    {
+                                        a3_1 = *(ptr - 2) - *(ptr - 3);
+                                        a3_1 += ((*(ptr - 4) - *(ptr - 1)) << 1) + (a3_1 << 2);
+
+                                        a3_2  = *(ptr + 2) - *(ptr + 1);
+                                        a3_2 += ((*(ptr) - *(ptr + 3)) << 1) + (a3_2 << 2);
+
+                                        A3_0 = PV_ABS(a3_0) - PV_MIN(PV_ABS(a3_1), PV_ABS(a3_2));
+
+                                        if (A3_0 > 0)
+                                        {
+                                            A3_0 += A3_0 << 2;
+                                            A3_0 = (A3_0 + 32) >> 6;
+                                            if (a3_0 > 0)
+                                            {
+                                                A3_0 = -A3_0;
+                                            }
+
+                                            delta = (*(ptr - 1) - *(ptr)) >> 1;
+                                            if (delta >= 0)
+                                            {
+                                                if (delta >= A3_0)
+                                                {
+                                                    delta = PV_MAX(A3_0, 0);
+                                                }
+                                            }
+                                            else
+                                            {
+                                                if (A3_0 > 0)
+                                                {
+                                                    delta = 0;
+                                                }
+                                                else
+                                                {
+                                                    delta = PV_MAX(A3_0, delta);
+                                                }
+                                            }
+
+                                            *(ptr - 1) = (uint8)(*(ptr - 1) - delta);
+                                            *(ptr) = (uint8)(*(ptr) + delta);
+                                        }
+                                    } /*threshold*/
+                                }
+                                ptr += w1;
+                            } /*index*/
+                        } /* Soft filter*/
+                    } /* boundary*/
+                } /*bc*/
+                /* Increment pointer to next row of pixels */
+                brwidth += pp_w;
+            }/*br*/
+            brwidth -= (pp_w << 1);
+
+            /****************** Deringing ***************************/
+            /* Process four blocks for the filtering        */
+            /********************************************************/
+            /* Loop over two rows of blocks */
+            for (br = mbr; br < mbr + 2; br++)
+            {
+                /* Loop over two columns of blocks in the row */
+                for (bc = mbc; bc < mbc + 2; bc++)
+                {
+                    /* Execute if the row and column counters are within the area */
+                    if (br < pp_h && bc < pp_w)
+                    {
+                        /* Set the index to the current block */
+                        index = brwidth + bc;
+
+                        /* Execute deringing if semaphore for deringing (bit-3 of pp_mod)
+                         * is set for the current block */
+                        if ((pp_mod[index]&0x04) != 0)
+                        {
+                            /* Don't process deringing if on an edge block */
+                            if (br > 0 && bc > 0 && br < pp_h - 1 && bc < pp_w - 1)
+                            {
+                                /* cnthflag = weighted average of HorzHflag of current,
+                                 * one above, previous blocks*/
+                                cnthflag = ((pp_mod[index] & 0x10) +
+                                            (pp_mod[index-pp_w] & 0x10) +
+                                            ((pp_mod[index-1] >> 1) & 0x10) +
+                                            ((pp_mod[index] >> 1) & 0x10)) >> 4; /* 4/26/00*/
+
+                                /* Do the deringing if decision flags indicate it's necessary */
+                                if (cnthflag < 3)
+                                {
+                                    /* if the data is chrominance info, get the correct
+                                     * quantization paramenter. One parameter per block. */
+                                    if (chr)
+                                    {
+                                        QP = QP_store[index];
+                                    }
+
+                                    /* Set amount to change luminance if it needs to be changed
+                                     * based on quantization parameter */
+                                    max_diff = (QP >> 2) + 4;
+
+                                    /* Set pointer to first pixel of current block */
+                                    ptr = rec + (brwidth << 6) + (bc << 3);
+
+                                    /* Find minimum and maximum value of pixel block */
+                                    FindMaxMin(ptr, &min_blk, &max_blk, incr);
+
+                                    /* threshold determination */
+                                    thres = (max_blk + min_blk + 1) >> 1;
+
+                                    /* If pixel range is greater or equal than DERING_THR, smooth the region */
+                                    if ((max_blk - min_blk) >= DERING_THR) /*smooth 8x8 region*/
+#ifndef NoMMX
+                                    {
+                                        /* smooth all pixels in the block*/
+                                        DeringAdaptiveSmoothMMX(ptr, width, thres, max_diff);
+                                    }
+#else
+                                    {
+                                        /* Setup the starting point of the region to smooth */
+                                        v0 = (br << 3) - 1;
+                                        h0 = (bc << 3) - 1;
+
+                                        /*smooth 8x8 region*/
+                                        AdaptiveSmooth_NoMMX(rec, v0, h0, v0 + 1, h0 + 1, thres, width, max_diff);
+                                    }
+#endif
+                                }/*cnthflag*/
+                            } /*dering br==1 or bc==1 (boundary block)*/
+                            else    /* Process the boundary blocks */
+                            {
+                                /* Decide to perform deblocking based on the semaphore flags
+                                   * of the neighboring blocks in each case. A certain number of
+                                 * hard filtering flags have to be set in order to signal need
+                                 * for smoothing */
+                                if (br > 0 && br < pp_h - 1)
+                                {
+                                    if (bc > 0)
+                                    {
+                                        cnthflag = ((pp_mod[index-pp_w] & 0x10) +
+                                                    (pp_mod[index] & 0x10) +
+                                                    ((pp_mod[index-1] >> 1) & 0x10)) >> 4;
+                                    }
+                                    else
+                                    {
+                                        cnthflag = ((pp_mod[index] & 0x10) +
+                                                    (pp_mod[index-pp_w] & 0x10) +
+                                                    ((pp_mod[index] >> 1) & 0x10)) >> 4;
+                                    }
+                                }
+                                else if (bc > 0 && bc < pp_w - 1)
+                                {
+                                    if (br > 0)
+                                    {
+                                        cnthflag = ((pp_mod[index-pp_w] & 0x10) +
+                                                    ((pp_mod[index-1] >> 1) & 0x10) +
+                                                    ((pp_mod[index] >> 1) & 0x10)) >> 4;
+                                    }
+                                    else
+                                    {
+                                        cnthflag = ((pp_mod[index] & 0x10) +
+                                                    ((pp_mod[index-1] >> 1) & 0x10) +
+                                                    ((pp_mod[index] >> 1) & 0x10)) >> 4;
+                                    }
+                                }
+                                else /* at the corner do default*/
+                                {
+                                    cnthflag = 0;
+                                }
+
+                                /* Do the deringing if decision flags indicate it's necessary */
+                                if (cnthflag < 2)
+                                {
+
+                                    /* if the data is chrominance info, get the correct
+                                                         * quantization paramenter. One parameter per block. */
+                                    if (chr)
+                                    {
+                                        QP = QP_store[index];
+                                    }
+
+                                    /* Set amount to change luminance if it needs to be changed
+                                     * based on quantization parameter */
+                                    max_diff = (QP >> 2) + 4;
+
+                                    /* Set pointer to first pixel of current block */
+                                    ptr = rec + (brwidth << 6) + (bc << 3);
+
+                                    /* Find minimum and maximum value of pixel block */
+                                    FindMaxMin(ptr, &min_blk, &max_blk, incr);
+
+                                    /* threshold determination */
+                                    thres = (max_blk + min_blk + 1) >> 1;
+
+                                    /* Setup the starting point of the region to smooth
+                                     * This is going to be a 4x4 region */
+                                    v0 = (br << 3) + 1;
+                                    h0 = (bc << 3) + 1;
+
+                                    /* If pixel range is greater or equal than DERING_THR, smooth the region */
+                                    if ((max_blk - min_blk) >= DERING_THR)
+                                    {
+                                        /* Smooth 4x4 region */
+                                        AdaptiveSmooth_NoMMX(rec, v0, h0, v0 - 3, h0 - 3, thres, width, max_diff);
+                                    }
+                                }/*cnthflag*/
+                            } /* br==0, bc==0*/
+                        }  /* dering*/
+                    } /*boundary condition*/
+                }/*bc*/
+                brwidth += pp_w;
+            }/*br*/
+            brwidth -= (pp_w << 1);
+        }/*mbc*/
+        brwidth += (pp_w << 1);
+    }/*mbr*/
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return ;
+}
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/combined_decode.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/combined_decode.cpp
new file mode 100644
index 0000000..6499233
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/combined_decode.cpp
@@ -0,0 +1,840 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h" /* video decoder function prototypes */
+#include "vlc_decode.h"
+#include "bitstream.h"
+#include "scaling.h"
+#include "mbtype_mode.h"
+
+#define OSCL_DISABLE_WARNING_CONDITIONAL_IS_CONSTANT
+/* ======================================================================== */
+/*  Function : DecodeFrameCombinedMode()                                    */
+/*  Purpose  : Decode a frame of MPEG4 bitstream in combined mode.          */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/*                                                                          */
+/*      03/30/2000 : Cleaned up and optimized the code.             */
+/*      03/31/2000 : Added proper handling of MB stuffing.          */
+/*      04/13/2000 : Rewrote this combined mode path completely     */
+/*                           so that it handles "Combined Mode With Error   */
+/*                           Resilience."  Now the code resembles the       */
+/*                           pseudo codes in MPEG-4 standard better.        */
+/*      10/13/2000 : Add fast VLC+dequant                           */
+/*      04/13/2001 : fix MB_stuffing                               */
+/*      08/07/2001 : remove MBzero                                  */
+/* ======================================================================== */
+PV_STATUS DecodeFrameCombinedMode(VideoDecData *video)
+{
+    PV_STATUS status;
+    int mbnum;
+    Vop *currVop = video->currVop;
+    BitstreamDecVideo *stream = video->bitstream;
+    int shortVideoHeader = video->shortVideoHeader;
+    int16 QP, *QPMB = video->QPMB;
+    uint8 *Mode = video->headerInfo.Mode;
+    int nTotalMB = video->nTotalMB;
+    int nMBPerRow = video->nMBPerRow;
+    int slice_counter;
+    uint32 tmpvar, long_zero_bits;
+    uint code;
+    int valid_stuffing;
+    int resync_marker_length;
+    int stuffing_length;
+
+    /* add this for error resilient, 05/18/2000 */
+    int32 startPacket;
+    int mb_start;
+    /* copy and pad to prev_Vop for INTER coding */
+    switch (currVop->predictionType)
+    {
+        case I_VOP :
+//      oscl_memset(Mode, MODE_INTRA, sizeof(uint8)*nTotalMB);
+            resync_marker_length = 17;
+            stuffing_length = 9;
+            break;
+        case P_VOP :
+            oscl_memset(video->motX, 0, sizeof(MOT)*4*nTotalMB);
+            oscl_memset(video->motY, 0, sizeof(MOT)*4*nTotalMB);
+//      oscl_memset(Mode, MODE_INTER, sizeof(uint8)*nTotalMB);
+            resync_marker_length = 16 + currVop->fcodeForward;
+            stuffing_length = 10;
+            break;
+        default :
+            mp4dec_log("DecodeFrameCombinedMode(): Vop type not supported.\n");
+            return PV_FAIL;
+    }
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    if (video->shortVideoHeader)
+    {
+        if (video->advanced_INTRA)
+        {
+            if (video->modified_quant)
+            {
+                video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader_AnnexIT;
+                video->vlcDecCoeffInter = &VlcDecTCOEFShortHeader_AnnexT;
+            }
+            else
+            {
+                video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader_AnnexI;
+                video->vlcDecCoeffInter = &VlcDecTCOEFShortHeader;
+            }
+        }
+        else
+        {
+            if (video->modified_quant)
+            {
+                video->vlcDecCoeffInter = video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader_AnnexT;
+            }
+            else
+            {
+                video->vlcDecCoeffInter = video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader;
+            }
+        }
+    }
+
+#endif
+
+    /** Initialize sliceNo ***/
+    mbnum = slice_counter = 0;
+//  oscl_memset(video->sliceNo, 0, sizeof(uint8)*nTotalMB);
+    QP = video->currVop->quantizer;
+
+    do
+    {
+        /* This section is equivalent to motion_shape_texture() */
+        /*    in the MPEG-4 standard.     04/13/2000          */
+        mb_start = mbnum;
+        video->usePrevQP = 0;             /*  04/27/01 */
+        startPacket = getPointer(stream);
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+        if (video->modified_quant)
+        {
+            video->QP_CHR = MQ_chroma_QP_table[QP];
+        }
+        else
+        {
+            video->QP_CHR = QP;     /* ANNEX_T */
+        }
+#endif
+        /* remove any stuffing bits */
+        BitstreamShowBits16(stream, stuffing_length, &code);
+        while (code == 1)
+        {
+            PV_BitstreamFlushBits(stream, stuffing_length);
+            BitstreamShowBits16(stream, stuffing_length, &code);
+        }
+
+        do
+        {
+            /* we need video->mbnum in lower level functions */
+            video->mbnum = mbnum;
+            video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow);
+            video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow;
+            /* assign slice number for each macroblocks */
+            video->sliceNo[mbnum] = (uint8) slice_counter;
+
+            /* decode COD, MCBPC, ACpred_flag, CPBY and DQUANT */
+            /* We have to discard stuffed MB header */
+            status = GetMBheader(video, &QP);
+
+            if (status != PV_SUCCESS)
+            {
+                VideoDecoderErrorDetected(video);
+                video->mbnum = mb_start;
+                movePointerTo(stream, (startPacket & -8));
+                break;
+            }
+
+            /* Store the QP value for later use in AC prediction */
+            QPMB[mbnum] = QP;
+
+            if (Mode[mbnum] != MODE_SKIPPED)
+            {
+                /* decode the DCT coeficients for the MB */
+                status = GetMBData(video);
+                if (status != PV_SUCCESS)
+                {
+                    VideoDecoderErrorDetected(video);
+                    video->mbnum = mb_start;
+                    movePointerTo(stream, (startPacket & -8));
+                    break;
+                }
+            }
+            else /* MODE_SKIPPED */
+            {
+                SkippedMBMotionComp(video); /*  08/04/05 */
+            }
+            // Motion compensation and put video->mblock->pred_block
+            mbnum++;
+
+            /* remove any stuffing bits */
+            BitstreamShowBits16(stream, stuffing_length, &code);
+            while (code == 1)
+            {
+                PV_BitstreamFlushBits(stream, stuffing_length);
+                BitstreamShowBits16(stream, stuffing_length, &code);
+            }
+
+            /* have we reached the end of the video packet or vop? */
+            if (shortVideoHeader)
+            {
+#ifdef PV_ANNEX_IJKT_SUPPORT
+                if (!video->slice_structure)
+                {
+#endif
+                    if (mbnum >= (int)(video->mbnum_row + 1)*video->nMBinGOB)   /*  10/11/01 */
+                    {
+                        if (mbnum >= nTotalMB) return PV_SUCCESS;
+                        status = BitstreamShowBits32(stream, GOB_RESYNC_MARKER_LENGTH, &tmpvar);
+
+                        if (tmpvar == GOB_RESYNC_MARKER)
+                        {
+                            break;
+                        }
+                        else
+                        {
+                            status = PV_BitstreamShowBitsByteAlign(stream, GOB_RESYNC_MARKER_LENGTH, &tmpvar);
+                            if (tmpvar == GOB_RESYNC_MARKER) break;
+                        }
+                    }
+#ifdef PV_ANNEX_IJKT_SUPPORT
+                }
+                else
+                {
+
+                    if (mbnum >= nTotalMB)  /* in case no valid stuffing  06/23/01 */
+                    {
+                        valid_stuffing = validStuffing_h263(stream);
+                        if (valid_stuffing == 0)
+                        {
+                            VideoDecoderErrorDetected(video);
+                            ConcealPacket(video, mb_start, nTotalMB, slice_counter);
+                        }
+                        return PV_SUCCESS;
+                    }
+                    /* ANNEX_K */
+                    PV_BitstreamShowBitsByteAlignNoForceStuffing(stream, 17, &tmpvar);
+                    if (tmpvar == RESYNC_MARKER)
+                    {
+                        valid_stuffing = validStuffing_h263(stream);
+                        if (valid_stuffing)
+                            break; /*  06/21/01 */
+                    }
+
+                }
+#endif
+            }
+            else
+            {
+                if (mbnum >= nTotalMB)  /* in case no valid stuffing  06/23/01 */
+                {
+                    /*  11/01/2002 if we are at the end of the frame and there is some garbage data
+                    at the end of the frame (i.e. no next startcode) break if the stuffing is valid */
+                    valid_stuffing = validStuffing(stream);
+                    if (valid_stuffing == 0)
+                    {
+                        /* end 11/01/2002 */
+                        VideoDecoderErrorDetected(video);
+                        ConcealPacket(video, mb_start, nTotalMB, slice_counter);
+                    }
+                    PV_BitstreamByteAlign(stream);
+                    return PV_SUCCESS;
+                }
+
+                status = PV_BitstreamShowBitsByteAlign(stream, 23, &tmpvar); /* this call is valid for f_code < 8 */
+                long_zero_bits = !tmpvar;
+
+                if ((tmpvar >> (23 - resync_marker_length)) == RESYNC_MARKER || long_zero_bits)
+                {
+                    valid_stuffing = validStuffing(stream);
+                    if (valid_stuffing)
+                        break; /*  06/21/01 */
+                }
+
+            }
+        }
+        while (TRUE);
+
+        if (shortVideoHeader)
+        { /* We need to check newgob to refresh quantizer */
+#ifdef PV_ANNEX_IJKT_SUPPORT
+            if (!video->slice_structure)
+            {
+#endif
+                while ((status = PV_GobHeader(video)) == PV_FAIL)
+                {
+                    if ((status = quickSearchGOBHeader(stream)) != PV_SUCCESS)
+                    {
+                        break;
+                    }
+                }
+
+                mbnum = currVop->gobNumber * video->nMBinGOB;
+#ifdef PV_ANNEX_IJKT_SUPPORT
+            }
+            else
+            {
+                while ((status = PV_H263SliceHeader(video, &mbnum)) == PV_FAIL)
+                {
+                    if ((status = quickSearchH263SliceHeader(stream)) != PV_SUCCESS)
+                    {
+                        break;
+                    }
+                }
+            }
+
+#endif
+        }
+        else
+        {
+            while ((status = PV_ReadVideoPacketHeader(video, &mbnum)) == PV_FAIL)
+            {
+                if ((status = quickSearchVideoPacketHeader(stream, resync_marker_length)) != PV_SUCCESS)
+                {
+                    break;
+                }
+            }
+        }
+
+        if (status == PV_END_OF_VOP)
+        {
+            mbnum = nTotalMB;
+        }
+
+        if (mbnum > video->mbnum + 1)
+        {
+            ConcealPacket(video, video->mbnum, mbnum, slice_counter);
+        }
+        QP = video->currVop->quantizer;
+        slice_counter++;
+        if (mbnum >= nTotalMB) break;
+
+    }
+    while (TRUE);
+    return PV_SUCCESS;
+}
+
+
+/* ============================================================================ */
+/*  Function : GetMBHeader()                                                    */
+/*  Purpose  : Decode MB header, not_coded, mcbpc, ac_pred_flag, cbpy, dquant.  */
+/*  In/out   :                                                                  */
+/*  Return   :                                                                  */
+/*  Modified :                                                                  */
+/*                                                                              */
+/*      3/29/00 : Changed the returned value and optimized the code.    */
+/*      4/01/01 : new ACDC prediction structure                         */
+/* ============================================================================ */
+PV_STATUS GetMBheader(VideoDecData *video, int16 *QP)
+{
+    BitstreamDecVideo *stream = video->bitstream;
+    int mbnum = video->mbnum;
+    uint8 *Mode = video->headerInfo.Mode;
+    int x_pos = video->mbnum_col;
+    typeDCStore *DC = video->predDC + mbnum;
+    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
+    typeDCACStore *DCAC_col = video->predDCAC_col;
+    const static int16  DQ_tab[4] = { -1, -2, 1, 2};
+
+    int CBPY, CBPC;
+    int MBtype, VopType;
+    int MCBPC;
+    uint DQUANT;
+    int comp;
+    Bool mb_coded;
+
+    VopType = video->currVop->predictionType;
+    mb_coded = ((VopType == I_VOP) ? TRUE : !BitstreamRead1Bits_INLINE(stream));
+
+    if (!mb_coded)
+    {
+        /* skipped macroblock */
+        Mode[mbnum] = MODE_SKIPPED;
+        //oscl_memset(DCAC_row, 0, sizeof(typeDCACStore));   /*  SKIPPED_ACDC */
+        //oscl_memset(DCAC_col, 0, sizeof(typeDCACStore));
+        ZERO_OUT_64BYTES(DCAC_row);
+        ZERO_OUT_64BYTES(DCAC_col); /*  08/12/05 */
+
+        for (comp = 0; comp < 6; comp++)
+        {
+            (*DC)[comp] = mid_gray;
+        }
+    }
+    else
+    {
+        /* coded macroblock */
+        if (VopType == I_VOP)
+        {
+            MCBPC = PV_VlcDecMCBPC_com_intra(stream);
+        }
+        else
+        {
+#ifdef PV_ANNEX_IJKT_SUPPORT
+            if (!video->deblocking)
+            {
+                MCBPC = PV_VlcDecMCBPC_com_inter(stream);
+            }
+            else
+            {
+                MCBPC = PV_VlcDecMCBPC_com_inter_H263(stream);
+            }
+#else
+            MCBPC = PV_VlcDecMCBPC_com_inter(stream);
+#endif
+        }
+
+        if (VLC_ERROR_DETECTED(MCBPC))
+        {
+            return PV_FAIL;
+        }
+
+        Mode[mbnum] = (uint8)(MBtype = MBtype_mode[MCBPC & 7]);
+        CBPC = (MCBPC >> 4) & 3;
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+        if (MBtype & INTRA_MASK)
+        {
+            if (!video->shortVideoHeader)
+            {
+                video->acPredFlag[mbnum] = (uint8) BitstreamRead1Bits(stream);
+            }
+            else
+            {
+                if (video->advanced_INTRA)
+                {
+                    if (!BitstreamRead1Bits(stream))
+                    {
+                        video->acPredFlag[mbnum] = 0;
+                    }
+                    else
+                    {
+                        video->acPredFlag[mbnum] = 1;
+                        if (BitstreamRead1Bits(stream))
+                        {
+                            video->mblock->direction = 0;
+                        }
+                        else
+                        {
+                            video->mblock->direction = 1;
+                        }
+                    }
+                }
+                else
+                {
+                    video->acPredFlag[mbnum] = 0;
+                }
+            }
+        }
+#else
+        if ((MBtype & INTRA_MASK) && !video->shortVideoHeader)
+        {
+            video->acPredFlag[mbnum] = (uint8) BitstreamRead1Bits_INLINE(stream);
+        }
+        else
+        {
+            video->acPredFlag[mbnum] = 0;
+        }
+#endif
+        CBPY = PV_VlcDecCBPY(stream, MBtype & INTRA_MASK); /* INTRA || INTRA_Q */
+        if (CBPY < 0)
+        {
+            return PV_FAIL;
+        }
+
+        // GW 04/23/99
+        video->headerInfo.CBP[mbnum] = (uint8)(CBPY << 2 | (CBPC & 3));
+#ifdef PV_ANNEX_IJKT_SUPPORT
+        if (MBtype & Q_MASK)
+        {
+            if (!video->modified_quant)
+            {
+                DQUANT = BitstreamReadBits16(stream, 2);
+                *QP += DQ_tab[DQUANT];
+
+                if (*QP < 1) *QP = 1;
+                else if (*QP > 31) *QP = 31;
+                video->QP_CHR = *QP;  /* ANNEX_T */
+            }
+            else
+            {
+                if (BitstreamRead1Bits(stream))
+                {
+                    if (BitstreamRead1Bits(stream))
+                    {
+                        *QP += DQ_tab_Annex_T_11[*QP];
+                    }
+                    else
+                    {
+                        *QP += DQ_tab_Annex_T_10[*QP];
+                    }
+                    if (*QP < 1) *QP = 1;
+                    else if (*QP > 31) *QP = 31;
+                }
+                else
+                {
+                    *QP = (int16)BitstreamReadBits16(stream, 5);
+                }
+                video->QP_CHR =  MQ_chroma_QP_table[*QP];
+            }
+        }
+#else
+        if (MBtype & Q_MASK)
+        {
+            DQUANT = BitstreamReadBits16(stream, 2);
+            *QP += DQ_tab[DQUANT];
+
+            if (*QP < 1) *QP = 1;
+            else if (*QP > 31) *QP = 31;
+        }
+#endif
+    }
+    return PV_SUCCESS;
+}
+
+
+
+
+
+/***********************************************************CommentBegin******
+*       3/10/00  : initial modification to the
+*                new PV-Decoder Lib format.
+*       4/2/2000 : Cleanup and error-handling modification.  This
+*                   function has been divided into several sub-functions for
+*                   better coding style and maintainance reason.  I also
+*                   greatly shrunk the code size here.
+*       9/18/2000 : VlcDecode+Dequant optimization *
+*       4/01/2001 : new ACDC prediction structure
+*       3/29/2002 : removed GetIntraMB and GetInterMB
+***********************************************************CommentEnd********/
+PV_STATUS GetMBData(VideoDecData *video)
+{
+    BitstreamDecVideo *stream = video->bitstream;
+    int mbnum = video->mbnum;
+    MacroBlock *mblock = video->mblock;
+    int16 *dataBlock;
+    PIXEL *c_comp;
+    uint mode = video->headerInfo.Mode[mbnum];
+    uint CBP = video->headerInfo.CBP[mbnum];
+    typeDCStore *DC = video->predDC + mbnum;
+    int intra_dc_vlc_thr = video->currVop->intraDCVlcThr;
+    int16 QP = video->QPMB[mbnum];
+    int16 QP_tmp = QP;
+    int width = video->width;
+    int  comp;
+    int  switched;
+    int ncoeffs[6] = {0, 0, 0, 0, 0, 0};
+    int *no_coeff = mblock->no_coeff;
+    int16 DC_coeff;
+    PV_STATUS status;
+
+#ifdef PV_POSTPROC_ON
+    /* post-processing */
+    uint8 *pp_mod[6];
+    int TotalMB = video->nTotalMB;
+    int MB_in_width = video->nMBPerRow;
+#endif
+    int y_pos = video->mbnum_row;
+    int x_pos = video->mbnum_col;
+    int32 offset = (int32)(y_pos << 4) * width + (x_pos << 4);
+
+    /* Decode each 8-by-8 blocks. comp 0 ~ 3 are luminance blocks, 4 ~ 5 */
+    /*  are chrominance blocks.   04/03/2000.                          */
+#ifdef PV_POSTPROC_ON
+    if (video->postFilterType != PV_NO_POST_PROC)
+    {
+        /** post-processing ***/
+        pp_mod[0] = video->pstprcTypCur + (y_pos << 1) * (MB_in_width << 1) + (x_pos << 1);
+        pp_mod[1] = pp_mod[0] + 1;
+        pp_mod[2] = pp_mod[0] + (MB_in_width << 1);
+        pp_mod[3] = pp_mod[2] + 1;
+        pp_mod[4] = video->pstprcTypCur + (TotalMB << 2) + mbnum;
+        pp_mod[5] = pp_mod[4] + TotalMB;
+    }
+#endif
+
+    /*  oscl_memset(mblock->block, 0, sizeof(typeMBStore));    Aug 9,2005 */
+
+    if (mode & INTRA_MASK) /* MODE_INTRA || MODE_INTRA_Q */
+    {
+        switched = 0;
+        if (intra_dc_vlc_thr)
+        {
+            if (video->usePrevQP)
+                QP_tmp = video->QPMB[mbnum-1];   /* running QP  04/26/01 */
+
+            switched = (intra_dc_vlc_thr == 7 || QP_tmp >= intra_dc_vlc_thr * 2 + 11);
+        }
+
+        mblock->DCScalarLum = cal_dc_scaler(QP, LUMINANCE_DC_TYPE);   /*  3/01/01 */
+        mblock->DCScalarChr = cal_dc_scaler(QP, CHROMINANCE_DC_TYPE);
+
+        for (comp = 0; comp < 6; comp++)
+        {
+            dataBlock = mblock->block[comp];    /* 10/20/2000 */
+
+            if (video->shortVideoHeader)
+            {
+#ifdef PV_ANNEX_IJKT_SUPPORT
+                if (!video->advanced_INTRA)
+                {
+#endif
+                    DC_coeff = (int16) BitstreamReadBits16_INLINE(stream, 8);
+
+                    if ((DC_coeff & 0x7f) == 0) /* 128 & 0  */
+                    {
+                        /* currently we will only signal FAIL for 128. We will ignore the 0 case  */
+                        if (DC_coeff == 128)
+                        {
+                            return PV_FAIL;
+                        }
+                        else
+                        {
+                            VideoDecoderErrorDetected(video);
+                        }
+                    }
+                    if (DC_coeff == 255)
+                    {
+                        DC_coeff = 128;
+                    }
+                    dataBlock[0] = (int16) DC_coeff;
+#ifdef PV_ANNEX_IJKT_SUPPORT
+                }
+#endif
+                ncoeffs[comp] = VlcDequantH263IntraBlock_SH(video, comp, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
+
+            }
+            else
+            {
+                if (switched == 0)
+                {
+                    status = PV_DecodePredictedIntraDC(comp, stream, &DC_coeff);
+                    if (status != PV_SUCCESS) return PV_FAIL;
+
+                    dataBlock[0] = (int16) DC_coeff;
+                }
+                ncoeffs[comp] = VlcDequantH263IntraBlock(video, comp,
+                                switched, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
+            }
+
+            if (VLC_ERROR_DETECTED(ncoeffs[comp]))
+            {
+                if (switched)
+                    return PV_FAIL;
+                else
+                {
+                    ncoeffs[comp] = 1;
+                    oscl_memset((dataBlock + 1), 0, sizeof(int16)*63);
+                }
+            }
+            no_coeff[comp] = ncoeffs[comp];
+
+#ifdef PV_POSTPROC_ON
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[comp] = (uint8) PostProcSemaphore(dataBlock);
+#endif
+        }
+        MBlockIDCT(video);
+    }
+    else      /* INTER modes */
+    {   /*  moved it here Aug 15, 2005 */
+        /* decode the motion vector (if there are any) */
+        status = PV_GetMBvectors(video, mode);
+        if (status != PV_SUCCESS)
+        {
+            return status;
+        }
+
+
+        MBMotionComp(video, CBP);
+        c_comp  = video->currVop->yChan + offset;
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+        for (comp = 0; comp < 4; comp++)
+        {
+            (*DC)[comp] = mid_gray;
+            if (CBP & (1 << (5 - comp)))
+            {
+                ncoeffs[comp] = VlcDequantH263InterBlock(video, comp, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
+                if (VLC_ERROR_DETECTED(ncoeffs[comp])) return PV_FAIL;
+
+                BlockIDCT(c_comp + (comp&2)*(width << 2) + 8*(comp&1), mblock->pred_block + (comp&2)*64 + 8*(comp&1), mblock->block[comp], width, ncoeffs[comp],
+                          mblock->bitmapcol[comp], mblock->bitmaprow[comp]);
+
+#ifdef PV_POSTPROC_ON
+                /* for inter just test for ringing */
+                if (video->postFilterType != PV_NO_POST_PROC)
+                    *pp_mod[comp] = (uint8)((ncoeffs[comp] > 3) ? 4 : 0);
+#endif
+            }
+            else
+            {
+                /* no IDCT for all zeros blocks  03/28/2002 */
+                /*              BlockIDCT();                */
+#ifdef PV_POSTPROC_ON
+                if (video->postFilterType != PV_NO_POST_PROC)
+                    *pp_mod[comp] = 0;
+#endif
+            }
+        }
+
+        video->QPMB[mbnum] = video->QP_CHR;     /* ANNEX_T */
+
+
+
+        (*DC)[4] = mid_gray;
+        if (CBP & 2)
+        {
+            ncoeffs[4] = VlcDequantH263InterBlock(video, 4, mblock->bitmapcol[4], &mblock->bitmaprow[4]);
+            if (VLC_ERROR_DETECTED(ncoeffs[4])) return PV_FAIL;
+
+            BlockIDCT(video->currVop->uChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 256, mblock->block[4], width >> 1, ncoeffs[4],
+                      mblock->bitmapcol[4], mblock->bitmaprow[4]);
+
+#ifdef PV_POSTPROC_ON
+            /* for inter just test for ringing */
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[4] = (uint8)((ncoeffs[4] > 3) ? 4 : 0);
+#endif
+        }
+        else
+        {
+            /* no IDCT for all zeros blocks  03/28/2002 */
+            /*              BlockIDCT();                */
+#ifdef PV_POSTPROC_ON
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[4] = 0;
+#endif
+        }
+        (*DC)[5] = mid_gray;
+        if (CBP & 1)
+        {
+            ncoeffs[5] = VlcDequantH263InterBlock(video, 5, mblock->bitmapcol[5], &mblock->bitmaprow[5]);
+            if (VLC_ERROR_DETECTED(ncoeffs[5])) return PV_FAIL;
+
+            BlockIDCT(video->currVop->vChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 264, mblock->block[5], width >> 1, ncoeffs[5],
+                      mblock->bitmapcol[5], mblock->bitmaprow[5]);
+
+#ifdef PV_POSTPROC_ON
+            /* for inter just test for ringing */
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[5] = (uint8)((ncoeffs[5] > 3) ? 4 : 0);
+#endif
+        }
+        else
+        {
+            /* no IDCT for all zeros blocks  03/28/2002 */
+            /*              BlockIDCT();                */
+#ifdef PV_POSTPROC_ON
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[5] = 0;
+#endif
+        }
+        video->QPMB[mbnum] = QP;  /* restore the QP values  ANNEX_T*/
+#else
+        for (comp = 0; comp < 4; comp++)
+        {
+            (*DC)[comp] = mid_gray;
+            if (CBP & (1 << (5 - comp)))
+            {
+                ncoeffs[comp] = VlcDequantH263InterBlock(video, comp, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
+                if (VLC_ERROR_DETECTED(ncoeffs[comp])) return PV_FAIL;
+
+                BlockIDCT(c_comp + (comp&2)*(width << 2) + 8*(comp&1), mblock->pred_block + (comp&2)*64 + 8*(comp&1), mblock->block[comp], width, ncoeffs[comp],
+                          mblock->bitmapcol[comp], mblock->bitmaprow[comp]);
+
+#ifdef PV_POSTPROC_ON
+                /* for inter just test for ringing */
+                if (video->postFilterType != PV_NO_POST_PROC)
+                    *pp_mod[comp] = (uint8)((ncoeffs[comp] > 3) ? 4 : 0);
+#endif
+            }
+            else
+            {
+                /* no IDCT for all zeros blocks  03/28/2002 */
+                /*              BlockIDCT();                */
+#ifdef PV_POSTPROC_ON
+                if (video->postFilterType != PV_NO_POST_PROC)
+                    *pp_mod[comp] = 0;
+#endif
+            }
+        }
+
+        (*DC)[4] = mid_gray;
+        if (CBP & 2)
+        {
+            ncoeffs[4] = VlcDequantH263InterBlock(video, 4, mblock->bitmapcol[4], &mblock->bitmaprow[4]);
+            if (VLC_ERROR_DETECTED(ncoeffs[4])) return PV_FAIL;
+
+            BlockIDCT(video->currVop->uChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 256, mblock->block[4], width >> 1, ncoeffs[4],
+                      mblock->bitmapcol[4], mblock->bitmaprow[4]);
+
+#ifdef PV_POSTPROC_ON
+            /* for inter just test for ringing */
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[4] = (uint8)((ncoeffs[4] > 3) ? 4 : 0);
+#endif
+        }
+        else
+        {
+            /* no IDCT for all zeros blocks  03/28/2002 */
+            /*              BlockIDCT();                */
+#ifdef PV_POSTPROC_ON
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[4] = 0;
+#endif
+        }
+        (*DC)[5] = mid_gray;
+        if (CBP & 1)
+        {
+            ncoeffs[5] = VlcDequantH263InterBlock(video, 5, mblock->bitmapcol[5], &mblock->bitmaprow[5]);
+            if (VLC_ERROR_DETECTED(ncoeffs[5])) return PV_FAIL;
+
+            BlockIDCT(video->currVop->vChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 264, mblock->block[5], width >> 1, ncoeffs[5],
+                      mblock->bitmapcol[5], mblock->bitmaprow[5]);
+
+#ifdef PV_POSTPROC_ON
+            /* for inter just test for ringing */
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[5] = (uint8)((ncoeffs[5] > 3) ? 4 : 0);
+#endif
+        }
+        else
+        {
+            /* no IDCT for all zeros blocks  03/28/2002 */
+            /*              BlockIDCT();                */
+#ifdef PV_POSTPROC_ON
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[5] = 0;
+#endif
+#endif  // PV_ANNEX_IJKT_SUPPORT
+
+
+
+
+
+
+    }
+
+    video->usePrevQP = 1;          /* should be set after decoding the first Coded  04/27/01 */
+    return PV_SUCCESS;
+}
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/conceal.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/conceal.cpp
new file mode 100644
index 0000000..e9ead01
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/conceal.cpp
@@ -0,0 +1,193 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h" /* video decoder function prototypes */
+#include "vlc_decode.h"
+#include "bitstream.h"
+#include "scaling.h"
+
+/* ====================================================================== /
+Function : ConcealTexture_I()
+Date     : 06/12/2001
+Purpose  : Conceal texture for I-partition
+In/out   :
+Return   :
+Modified :
+/ ====================================================================== */
+void ConcealTexture_I(VideoDecData *video, int32 startFirstPartition, int mb_start, int mb_stop, int slice_counter)
+{
+    int mbnum;
+    BitstreamDecVideo *stream = video->bitstream;
+    int16 QP;
+    int intra_dc_vlc_thr = video->currVop->intraDCVlcThr;
+
+    movePointerTo(stream, startFirstPartition);
+
+    video->usePrevQP = 0;
+    for (mbnum = mb_start; mbnum < mb_stop; mbnum++)
+    {
+        video->mbnum = mbnum;
+        video->mbnum_row = PV_GET_ROW(mbnum, video->nMBPerRow);
+        video->mbnum_col = mbnum - video->mbnum_row * video->nMBPerRow;
+        video->sliceNo[mbnum] = (uint8) slice_counter;
+        QP = video->QPMB[mbnum];
+        PV_VlcDecMCBPC_com_intra(stream);
+        GetMBheaderDataPart_DQUANT_DC(video, &QP);
+
+        if (intra_dc_vlc_thr)
+        {
+            if (video->usePrevQP)
+                QP = video->QPMB[mbnum-1];
+            if (intra_dc_vlc_thr == 7 || QP >= intra_dc_vlc_thr*2 + 11)  /* if switched then conceal from previous frame  */
+            {
+                ConcealPacket(video, mbnum, mb_stop, slice_counter);
+                video->mbnum = mb_stop - 1;
+                video->mbnum_row = PV_GET_ROW(video->mbnum, video->nMBPerRow);
+                video->mbnum_col = video->mbnum - video->mbnum_row * video->nMBPerRow;
+                break;
+            }
+        }
+
+        video->headerInfo.CBP[mbnum] = 0;
+        video->acPredFlag[mbnum] = 0;
+        GetMBData_DataPart(video);
+        video->usePrevQP = 1;
+    }
+    return;
+}
+
+/* ====================================================================== /
+Function : ConcealTexture_P()
+Date     : 05/16/2000
+Purpose  : Conceal texture for P-partition
+In/out   :
+Return   :
+/ ====================================================================== */
+
+void ConcealTexture_P(VideoDecData *video, int mb_start, int mb_stop, int slice_counter)
+{
+    int mbnum;
+
+    for (mbnum = mb_start; mbnum < mb_stop; mbnum++)
+    {
+        video->mbnum = mbnum;
+        video->mbnum_row = PV_GET_ROW(mbnum, video->nMBPerRow);
+        video->mbnum_col = mbnum - video->mbnum_row * video->nMBPerRow;
+        video->sliceNo[mbnum] = (uint8) slice_counter;
+        oscl_memset(video->mblock->block, 0, sizeof(typeMBStore));
+        /*  to get rid of dark region caused by INTRA blocks */
+        /* 05/19/2000 */
+        if (video->headerInfo.Mode[mbnum] & INTER_MASK)
+        {
+            MBMotionComp(video, 0);
+        }
+        else
+        {
+            video->headerInfo.Mode[mbnum] = MODE_SKIPPED;
+            SkippedMBMotionComp(video);
+        }
+    }
+
+    return;
+}
+
+/***************************************************************
+Function:   ConcealPacket
+Purpose :   Conceal motion and texture of a packet by direct
+copying from previous frame.
+Returned:   void
+Modified:
+*************************************************************/
+void ConcealPacket(VideoDecData *video,
+                   int mb_start,
+                   int mb_stop,
+                   int slice_counter)
+{
+    int i;
+    for (i = mb_start; i < mb_stop; i++)
+    {
+        CopyVopMB(video->currVop, video->concealFrame, i, video->width, video->height);
+        video->sliceNo[i] = (uint8) slice_counter;
+        video->headerInfo.Mode[i] = MODE_SKIPPED;
+    }
+
+    return;
+}
+
+/****************************************************************************
+Function:   CopyVopMB
+Purpose :   Fill a macroblock with previous Vop.
+Returned    :   void
+Modified:   6/04/2001 rewrote the function
+            copies from concealFrame
+****************************************************************************/
+void CopyVopMB(Vop *curr, uint8 *prevFrame, int mbnum, int width_Y, int height)
+{
+    int width_C = width_Y >> 1;
+    int row = MB_SIZE;
+    uint8              *y1, *y2, *u1, *u2, *v1, *v2;
+    int xpos, ypos, MB_in_width;
+    int32 lumstart, chrstart, size;
+
+    MB_in_width = (width_Y + 15) >> 4;
+    ypos = PV_GET_ROW(mbnum, MB_in_width);
+    xpos = mbnum - ypos * MB_in_width;
+    lumstart = (ypos << 4) * (int32)width_Y  + (xpos << 4);
+    chrstart = (ypos << 3) * (int32)width_C  + (xpos << 3);
+
+    size = (int32)height * width_Y;
+
+    y1 =  curr->yChan + lumstart;
+    u1 =  curr->uChan + chrstart;
+    v1 =  curr->vChan + chrstart;
+    y2 =  prevFrame + lumstart;
+    u2 =  prevFrame + size + chrstart;
+    v2 =  prevFrame + size + (size >> 2) + chrstart;
+    while (row)
+    {
+        oscl_memcpy(y1, y2, MB_SIZE);
+        y1 += width_Y;
+        y2 += width_Y;
+        oscl_memcpy(y1, y2, MB_SIZE);
+        y1 += width_Y;
+        y2 += width_Y;
+        oscl_memcpy(y1, y2, MB_SIZE);
+        y1 += width_Y;
+        y2 += width_Y;
+        oscl_memcpy(y1, y2, MB_SIZE);
+        y1 += width_Y;
+        y2 += width_Y;
+
+        oscl_memcpy(u1, u2, B_SIZE);
+        u1 += width_C;
+        u2 += width_C;
+        oscl_memcpy(u1, u2, B_SIZE);
+        u1 += width_C;
+        u2 += width_C;
+
+        oscl_memcpy(v1, v2, B_SIZE);
+        v1 += width_C;
+        v2 += width_C;
+        oscl_memcpy(v1, v2, B_SIZE);
+        v1 += width_C;
+        v2 += width_C;
+
+        row -= 4;
+    }
+    return;
+}               /* CopyVopMB */
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/datapart_decode.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/datapart_decode.cpp
new file mode 100644
index 0000000..00db04b
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/datapart_decode.cpp
@@ -0,0 +1,794 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h"
+#include "vlc_decode.h"
+#include "bitstream.h"
+#include "scaling.h"
+#include "mbtype_mode.h"
+#include "idct.h"
+
+#define OSCL_DISABLE_WARNING_CONDITIONAL_IS_CONSTANT
+/* ======================================================================== */
+/*  Function : DecodeFrameDataPartMode()                                    */
+/*  Purpose  : Decode a frame of MPEG4 bitstream in datapartitioning mode.  */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Modified :                                                              */
+/*                                                                          */
+/*      04/25/2000 : Rewrite the data partitioning path completely  */
+/*                           according to the pseudo codes in MPEG-4        */
+/*                           standard.                                      */
+/*  Modified : 09/18/2000 add fast VlcDecode+Dequant                    */
+/*             04/17/2001 cleanup                                       */
+/* ======================================================================== */
+PV_STATUS DecodeFrameDataPartMode(VideoDecData *video)
+{
+    PV_STATUS status;
+    Vop *currVop = video->currVop;
+    BitstreamDecVideo *stream = video->bitstream;
+
+    int nMBPerRow = video->nMBPerRow;
+
+    int vopType = currVop->predictionType;
+    int mbnum;
+    int nTotalMB = video->nTotalMB;
+    int slice_counter;
+    int resync_marker_length;
+
+    /* copy and pad to prev_Vop for INTER coding */
+    switch (vopType)
+    {
+        case I_VOP :
+//      oscl_memset(Mode, MODE_INTRA, sizeof(uint8)*nTotalMB);
+            resync_marker_length = 17;
+            break;
+        case P_VOP :
+            oscl_memset(video->motX, 0, sizeof(MOT)*4*nTotalMB);
+            oscl_memset(video->motY, 0, sizeof(MOT)*4*nTotalMB);
+//      oscl_memset(Mode, MODE_INTER, sizeof(uint8)*nTotalMB);
+            resync_marker_length = 16 + currVop->fcodeForward;
+            break;
+        default :
+            mp4dec_log("DecodeFrameDataPartMode(): Vop type not supported.\n");
+            return PV_FAIL;
+    }
+
+    /** Initialize sliceNo ***/
+    mbnum = slice_counter = 0;
+//  oscl_memset(video->sliceNo, 0, sizeof(uint8)*nTotalMB);
+
+    do
+    {
+        /* This section is equivalent to motion_shape_texture() */
+        /* in the MPEG-4 standard.            04/13/2000      */
+        video->mbnum = mbnum;
+        video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow);   /*  This is needed if nbnum is read from the packet header */
+        video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow;
+
+        switch (vopType)
+        {
+            case I_VOP :
+                status = DecodeDataPart_I_VideoPacket(video, slice_counter);
+                break;
+
+            case P_VOP :
+                status = DecodeDataPart_P_VideoPacket(video, slice_counter);
+                break;
+
+            default :
+                mp4dec_log("DecodeFrameDataPartMode(): Vop type not supported.\n");
+                return PV_FAIL;
+        }
+
+        while ((status = PV_ReadVideoPacketHeader(video, &mbnum)) == PV_FAIL)
+        {
+            if ((status = quickSearchVideoPacketHeader(stream, resync_marker_length)) != PV_SUCCESS)
+            {
+                break;
+            }
+        }
+
+        if (status == PV_END_OF_VOP)
+        {
+            mbnum = nTotalMB;
+        }
+
+        if (mbnum > video->mbnum + 1)
+        {
+            ConcealPacket(video, video->mbnum, mbnum, slice_counter);
+        }
+        slice_counter++;
+        if (mbnum >= nTotalMB)
+        {
+            break;
+        }
+
+
+    }
+    while (TRUE);
+
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : DecodeDataPart_I_VideoPacket()                               */
+/*  Date     : 04/25/2000                                                   */
+/*  Purpose  : Decode Data Partitioned Mode Video Packet in I-VOP           */
+/*  In/out   :                                                              */
+/*  Return   : PV_SUCCESS if successed, PV_FAIL if failed.                  */
+/*  Modified : 09/18/2000 add fast VlcDecode+Dequant                    */
+/*             04/01/2001 fixed MB_stuffing, removed unnecessary code   */
+/* ======================================================================== */
+PV_STATUS DecodeDataPart_I_VideoPacket(VideoDecData *video, int slice_counter)
+{
+    PV_STATUS status;
+    uint8 *Mode = video->headerInfo.Mode;
+    BitstreamDecVideo *stream = video->bitstream;
+    int  nTotalMB = video->nTotalMB;
+    int  mbnum, mb_start, mb_end;
+    int16 QP, *QPMB = video->QPMB;
+    int  MBtype, MCBPC, CBPY;
+    uint32 tmpvar;
+    uint code;
+    int nMBPerRow = video->nMBPerRow;
+    Bool valid_stuffing;
+    int32 startSecondPart, startFirstPart = getPointer(stream);
+
+    /* decode the first partition */
+    QP = video->currVop->quantizer;
+    mb_start = mbnum = video->mbnum;
+    video->usePrevQP = 0;         /*  04/27/01 */
+
+
+    BitstreamShowBits16(stream, 9, &code);
+    while (code == 1)
+    {
+        PV_BitstreamFlushBits(stream, 9);
+        BitstreamShowBits16(stream, 9, &code);
+    }
+
+    do
+    {
+        /* decode COD, MCBPC, ACpred_flag, CPBY and DQUANT */
+        MCBPC = PV_VlcDecMCBPC_com_intra(stream);
+
+        if (!VLC_ERROR_DETECTED(MCBPC))
+        {
+            Mode[mbnum] = (uint8)(MBtype = MBtype_mode[MCBPC & 7]);
+            video->headerInfo.CBP[mbnum] = (uint8)((MCBPC >> 4) & 3);
+            status = GetMBheaderDataPart_DQUANT_DC(video, &QP);
+            video->usePrevQP = 1;        /* set it after the first coded MB      04/27/01 */
+        }
+        else
+        {
+            /* Report the error to the application.   06/20/2000 */
+            VideoDecoderErrorDetected(video);
+            video->mbnum = mb_start;
+            movePointerTo(stream, startFirstPart);
+            return PV_FAIL;
+        }
+
+        video->sliceNo[mbnum] = (uint8) slice_counter;
+        QPMB[mbnum] = QP;
+        video->mbnum = ++mbnum;
+
+        BitstreamShowBits16(stream, 9, &code);
+        while (code == 1)
+        {
+            PV_BitstreamFlushBits(stream, 9);
+            BitstreamShowBits16(stream, 9, &code);
+        }
+        /* have we reached the end of the video packet or vop? */
+        status = BitstreamShowBits32(stream, DC_MARKER_LENGTH, &tmpvar);
+
+    }
+    while (tmpvar != DC_MARKER && video->mbnum < nTotalMB);
+
+    if (tmpvar == DC_MARKER)
+    {
+        PV_BitstreamFlushBits(stream, DC_MARKER_LENGTH);
+    }
+    else
+    {
+        status = quickSearchDCM(stream);
+        if (status == PV_SUCCESS)
+        {
+            /* only way you can end up being here is in the last packet,and there is stuffing at
+            the end of the first partition */
+            PV_BitstreamFlushBits(stream, DC_MARKER_LENGTH);
+        }
+        else
+        {
+            /* Report the error to the application.   06/20/2000 */
+            VideoDecoderErrorDetected(video);
+            movePointerTo(stream, startFirstPart);
+            video->mbnum = mb_start;
+            /* concealment will be taken care of in the upper layer */
+            return PV_FAIL;
+        }
+    }
+
+    /* decode the second partition */
+    startSecondPart = getPointer(stream);
+
+    mb_end = video->mbnum;
+
+    for (mbnum = mb_start; mbnum < mb_end; mbnum++)
+    {
+        MBtype = Mode[mbnum];
+        /* No skipped mode in I-packets  3/1/2001    */
+        video->mbnum = mbnum;
+
+        video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow);   /*  This is needed if nbnum is read from the packet header */
+        video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow;
+        /* there is always acdcpred in DataPart mode  04/10/01 */
+        video->acPredFlag[mbnum] = (uint8) BitstreamRead1Bits(stream);
+
+        CBPY = PV_VlcDecCBPY(stream, MBtype & INTRA_MASK); /* MODE_INTRA || MODE_INTRA_Q */
+        if (CBPY < 0)
+        {
+            /* Report the error to the application.   06/20/2000 */
+            VideoDecoderErrorDetected(video);
+            movePointerTo(stream, startSecondPart); /*  */
+            /* Conceal packet,  05/15/2000 */
+            ConcealTexture_I(video, startFirstPart, mb_start, mb_end, slice_counter);
+            return PV_FAIL;
+        }
+
+        video->headerInfo.CBP[mbnum] |= (uint8)(CBPY << 2);
+    }
+
+    video->usePrevQP = 0;
+
+    for (mbnum = mb_start; mbnum < mb_end; mbnum++)
+    {
+        video->mbnum = mbnum;
+
+        video->mbnum_row = PV_GET_ROW(mbnum , nMBPerRow);  /*  This is needed if nbnum is read from the packet header */
+        video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow;
+        /* No skipped mode in I-packets  3/1/2001    */
+        /* decode the DCT coeficients for the MB */
+        status = GetMBData_DataPart(video);
+        if (status != PV_SUCCESS)
+        {
+            /* Report the error to the application.   06/20/2000 */
+            VideoDecoderErrorDetected(video);
+            movePointerTo(stream, startSecondPart); /*  */
+            /* Conceal packet,  05/15/2000 */
+            ConcealTexture_I(video, startFirstPart, mb_start, mb_end, slice_counter);
+            return status;
+        }
+        video->usePrevQP = 1;           /*  04/27/01 should be set after decoding first MB */
+    }
+
+    valid_stuffing = validStuffing(stream);
+    if (!valid_stuffing)
+    {
+        VideoDecoderErrorDetected(video);
+        movePointerTo(stream, startSecondPart);
+        ConcealTexture_I(video, startFirstPart, mb_start, mb_end, slice_counter);
+        return PV_FAIL;
+    }
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : DecodeDataPart_P_VideoPacket()                               */
+/*  Date     : 04/25/2000                                                   */
+/*  Purpose  : Decode Data Partitioned Mode Video Packet in P-VOP           */
+/*  In/out   :                                                              */
+/*  Return   : PV_SUCCESS if successed, PV_FAIL if failed.                  */
+/*  Modified :   09/18/2000,  fast VlcDecode+Dequant                        */
+/*              04/13/2001,  fixed MB_stuffing, new ACDC pred structure,  */
+/*                              cleanup                                     */
+/*              08/07/2001,  remove MBzero                              */
+/* ======================================================================== */
+PV_STATUS DecodeDataPart_P_VideoPacket(VideoDecData *video, int slice_counter)
+{
+    PV_STATUS status;
+    uint8 *Mode = video->headerInfo.Mode;
+    BitstreamDecVideo *stream = video->bitstream;
+    int nTotalMB = video->nTotalMB;
+    int mbnum, mb_start, mb_end;
+    int16 QP, *QPMB = video->QPMB;
+    int MBtype, CBPY;
+    Bool valid_stuffing;
+    int intra_MB;
+    uint32 tmpvar;
+    uint code;
+    int32  startFirstPart, startSecondPart;
+    int nMBPerRow = video->nMBPerRow;
+    uint8 *pbyte;
+    /* decode the first partition */
+    startFirstPart = getPointer(stream);
+    mb_start = video->mbnum;
+    video->usePrevQP = 0;            /*  04/27/01 */
+
+    BitstreamShowBits16(stream, 10, &code);
+    while (code == 1)
+    {
+        PV_BitstreamFlushBits(stream, 10);
+        BitstreamShowBits16(stream, 10, &code);
+    }
+
+    do
+    {
+        /* decode COD, MCBPC, ACpred_flag, CPBY and DQUANT */
+        /* We have to discard stuffed MB header */
+
+        status = GetMBheaderDataPart_P(video);
+
+        if (status != PV_SUCCESS)
+        {
+            /* Report the error to the application.   06/20/2000 */
+            VideoDecoderErrorDetected(video);
+            movePointerTo(stream, startFirstPart);
+            video->mbnum = mb_start;
+            return PV_FAIL;
+        }
+
+        /* we must update slice_counter before motion vector decoding.   */
+        video->sliceNo[video->mbnum] = (uint8) slice_counter;
+
+        if (Mode[video->mbnum] & INTER_MASK) /* INTER || INTER_Q || INTER_4V */
+        {
+            /* decode the motion vector (if there are any) */
+            status = PV_GetMBvectors(video, Mode[video->mbnum]);
+            if (status != PV_SUCCESS)
+            {
+                /* Report the error to the application.   06/20/2000 */
+                VideoDecoderErrorDetected(video);
+                movePointerTo(stream, startFirstPart);
+                video->mbnum = mb_start;
+                return PV_FAIL;
+            }
+        }
+        video->mbnum++;
+
+        video->mbnum_row = PV_GET_ROW(video->mbnum, nMBPerRow);   /*  This is needed if mbnum is read from the packet header */
+        video->mbnum_col = video->mbnum - video->mbnum_row * nMBPerRow;
+
+        BitstreamShowBits16(stream, 10, &code);
+        while (code == 1)
+        {
+            PV_BitstreamFlushBits(stream, 10);
+            BitstreamShowBits16(stream, 10, &code);
+        }
+        /* have we reached the end of the video packet or vop? */
+        status = BitstreamShowBits32(stream, MOTION_MARKER_COMB_LENGTH, &tmpvar);
+        /*      if (status != PV_SUCCESS && status != PV_END_OF_BUFFER) return status;  */
+    }
+    while (tmpvar != MOTION_MARKER_COMB && video->mbnum < nTotalMB);
+
+    if (tmpvar == MOTION_MARKER_COMB)
+    {
+        PV_BitstreamFlushBits(stream, MOTION_MARKER_COMB_LENGTH);
+    }
+    else
+    {
+        status = quickSearchMotionMarker(stream);
+        if (status == PV_SUCCESS)
+        {
+            /* only way you can end up being here is in the last packet,and there is stuffing at
+            the end of the first partition */
+            PV_BitstreamFlushBits(stream, MOTION_MARKER_COMB_LENGTH);
+        }
+        else
+        {
+            /* Report the error to the application.   06/20/2000 */
+            VideoDecoderErrorDetected(video);
+            movePointerTo(stream, startFirstPart);
+            video->mbnum = mb_start;
+            /* concealment will be taken care of in the upper layer  */
+            return PV_FAIL;
+        }
+    }
+
+    /* decode the second partition */
+    startSecondPart = getPointer(stream);
+    QP = video->currVop->quantizer;
+
+    mb_end = video->mbnum;
+
+    for (mbnum = mb_start; mbnum < mb_end; mbnum++)
+    {
+        MBtype = Mode[mbnum];
+
+        if (MBtype == MODE_SKIPPED)
+        {
+            QPMB[mbnum] = QP; /*  03/01/01 */
+            continue;
+        }
+        intra_MB = (MBtype & INTRA_MASK); /* (MBtype == MODE_INTRA || MBtype == MODE_INTRA_Q) */
+        video->mbnum = mbnum;
+        video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow);   /*  This is needed if nbnum is read from the packet header */
+        video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow;
+
+        /* there is always acdcprediction in DataPart mode    04/10/01 */
+        if (intra_MB)
+        {
+            video->acPredFlag[mbnum] = (uint8) BitstreamRead1Bits_INLINE(stream);
+        }
+
+        CBPY = PV_VlcDecCBPY(stream, intra_MB);
+        if (CBPY < 0)
+        {
+            /* Report the error to the application.   06/20/2000 */
+            VideoDecoderErrorDetected(video);
+            /* Conceal second partition,  5/15/2000 */
+            movePointerTo(stream, startSecondPart);
+            ConcealTexture_P(video, mb_start, mb_end, slice_counter);
+            return PV_FAIL;
+        }
+
+        video->headerInfo.CBP[mbnum] |= (uint8)(CBPY << 2);
+        if (intra_MB || MBtype == MODE_INTER_Q)                     /*  04/26/01 */
+        {
+            status = GetMBheaderDataPart_DQUANT_DC(video, &QP);
+            if (status != PV_SUCCESS) return status;
+        }
+        video->usePrevQP = 1;        /*  04/27/01 */
+        QPMB[mbnum] = QP;
+    }
+
+    video->usePrevQP = 0;  /*  04/27/01 */
+
+    for (mbnum = mb_start; mbnum < mb_end; mbnum++)
+    {
+        video->mbnum = mbnum;
+        video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow);  /*  This is needed if nbnum is read from the packet header */
+        video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow;
+
+
+        if (Mode[mbnum] != MODE_SKIPPED)
+        {
+            /* decode the DCT coeficients for the MB */
+            status = GetMBData_DataPart(video);
+            if (status != PV_SUCCESS)
+            {
+                /* Report the error to the application.   06/20/2000 */
+                VideoDecoderErrorDetected(video);
+
+                /* Conceal second partition,  5/15/2000 */
+                movePointerTo(stream, startSecondPart);
+                ConcealTexture_P(video, mb_start, mb_end, slice_counter);
+                return status;
+            }
+            video->usePrevQP = 1;  /*  04/27/01 */
+        }
+        else
+        {   // SKIPPED
+
+            /* Motion compensation and put it to video->mblock->pred_block */
+            SkippedMBMotionComp(video);
+
+            //oscl_memset(video->predDCAC_row + video->mbnum_col, 0, sizeof(typeDCACStore)); /*  SKIPPED_ACDC */
+            //oscl_memset(video->predDCAC_col, 0, sizeof(typeDCACStore));
+            /*  08/08/2005 */
+            pbyte = (uint8*)(video->predDCAC_row + video->mbnum_col);
+            ZERO_OUT_64BYTES(pbyte);
+            pbyte = (uint8*)(video->predDCAC_col);
+            ZERO_OUT_64BYTES(pbyte);
+
+        }
+    }
+
+    valid_stuffing = validStuffing(stream);   /*  */
+    if (!valid_stuffing)
+    {
+        VideoDecoderErrorDetected(video);
+        movePointerTo(stream, startSecondPart); /*  */
+        ConcealTexture_P(video, mb_start, mb_end, slice_counter);
+
+        return PV_FAIL;
+    }
+    return PV_SUCCESS;
+}
+
+
+/* ======================================================================== */
+/*  Function : GetMBheaderDataPart_DQUANT_DC()                              */
+/*  Date     : 04/26/2000                                                   */
+/*  Purpose  : Decode DQUANT and DC in Data Partitioned Mode for both       */
+/*             I-VOP and P-VOP.                                             */
+/*  In/out   :                                                              */
+/*  Return   : PV_SUCCESS if successed, PV_FAIL if failed.                  */
+/*  Modified : 02/13/2001 new ACDC prediction structure,        */
+/*                                       cleanup                            */
+/* ======================================================================== */
+PV_STATUS GetMBheaderDataPart_DQUANT_DC(VideoDecData *video, int16 *QP)
+{
+    PV_STATUS status = PV_SUCCESS;
+    BitstreamDecVideo *stream = video->bitstream;
+    int mbnum = video->mbnum;
+    int intra_dc_vlc_thr = video->currVop->intraDCVlcThr;
+    uint8 *Mode = video->headerInfo.Mode;
+    int  MBtype = Mode[mbnum];
+    typeDCStore *DC = video->predDC + mbnum;
+    int  comp;
+    Bool switched;
+    uint  DQUANT;
+    int16 QP_tmp;
+
+    const static int  DQ_tab[4] = { -1, -2, 1, 2};
+
+    if (MBtype & Q_MASK)             /* INTRA_Q || INTER_Q */
+    {
+        DQUANT = BitstreamReadBits16(stream, 2);
+        *QP += DQ_tab[DQUANT];
+
+        if (*QP < 1) *QP = 1;
+        else if (*QP > 31) *QP = 31;
+    }
+    if (MBtype & INTRA_MASK)  /* INTRA || INTRA_Q */ /* no switch, code DC separately */
+    {
+        QP_tmp = *QP;                      /* running QP  04/26/01*/
+        switched = 0;
+        if (intra_dc_vlc_thr)                 /*  04/27/01 */
+        {
+            if (video->usePrevQP)
+                QP_tmp = video->QPMB[mbnum-1];
+            switched = (intra_dc_vlc_thr == 7 || QP_tmp >= intra_dc_vlc_thr * 2 + 11);
+        }
+        if (!switched)
+        {
+            for (comp = 0; comp < 6; comp++)
+            {
+                status = PV_DecodePredictedIntraDC(comp, stream, (*DC + comp));   /*  03/01/01 */
+                if (status != PV_SUCCESS) return PV_FAIL;
+            }
+        }
+        else
+        {
+            for (comp = 0; comp < 6; comp++)
+            {
+                (*DC)[comp] = 0;   /*  04/26/01 needed for switched case*/
+            }
+        }
+    }
+    return status;
+}
+
+
+/***********************************************************CommentBegin******
+*       04/25/2000 : Initial modification to the new PV Lib format.
+*       04/17/2001 : new ACDC pred structure
+***********************************************************CommentEnd********/
+PV_STATUS GetMBheaderDataPart_P(VideoDecData *video)
+{
+    BitstreamDecVideo *stream = video->bitstream;
+    int mbnum = video->mbnum;
+    uint8 *Mode = video->headerInfo.Mode;
+    typeDCStore *DC = video->predDC + mbnum;
+    uint no_dct_flag;
+    int comp;
+    int MCBPC;
+
+    no_dct_flag = BitstreamRead1Bits_INLINE(stream);
+
+    if (no_dct_flag)
+    {
+        /* skipped macroblock */
+        Mode[mbnum] = MODE_SKIPPED;
+
+        for (comp = 0; comp < 6; comp++)
+        {
+            (*DC)[comp] = mid_gray;
+            /*  ACDC REMOVE AC coefs are set in DecodeDataPart_P */
+        }
+    }
+    else
+    {
+        /* coded macroblock */
+        MCBPC = PV_VlcDecMCBPC_com_inter(stream);
+
+        if (VLC_ERROR_DETECTED(MCBPC))
+        {
+            return PV_FAIL;
+        }
+
+        Mode[mbnum] = (uint8)MBtype_mode[MCBPC & 7];
+        video->headerInfo.CBP[mbnum] = (uint8)((MCBPC >> 4) & 3);
+    }
+
+    return PV_SUCCESS;
+}
+
+
+/***********************************************************CommentBegin******
+*       04/17/01  new ACDC pred structure, reorganized code, cleanup
+***********************************************************CommentEnd********/
+PV_STATUS GetMBData_DataPart(VideoDecData *video)
+{
+    int mbnum = video->mbnum;
+    int16 *dataBlock;
+    MacroBlock *mblock = video->mblock;
+    int QP = video->QPMB[mbnum];
+    int32 offset;
+    PIXEL *c_comp;
+    int width = video->width;
+    int intra_dc_vlc_thr = video->currVop->intraDCVlcThr;
+    uint CBP = video->headerInfo.CBP[mbnum];
+    uint8 mode = video->headerInfo.Mode[mbnum];
+    int x_pos = video->mbnum_col;
+    typeDCStore *DC = video->predDC + mbnum;
+    int  ncoeffs[6], *no_coeff = mblock->no_coeff;
+    int  comp;
+    Bool  switched;
+    int QP_tmp = QP;
+
+    int y_pos = video->mbnum_row;
+#ifdef PV_POSTPROC_ON
+    uint8 *pp_mod[6];
+    int TotalMB = video->nTotalMB;
+    int MB_in_width = video->nMBPerRow;
+#endif
+
+
+
+    /*****
+    *     Decoding of the 6 blocks (depending on transparent pattern)
+    *****/
+#ifdef PV_POSTPROC_ON
+    if (video->postFilterType != PV_NO_POST_PROC)
+    {
+        /** post-processing ***/
+        pp_mod[0] = video->pstprcTypCur + (y_pos << 1) * (MB_in_width << 1) + (x_pos << 1);
+        pp_mod[1] = pp_mod[0] + 1;
+        pp_mod[2] = pp_mod[0] + (MB_in_width << 1);
+        pp_mod[3] = pp_mod[2] + 1;
+        pp_mod[4] = video->pstprcTypCur + (TotalMB << 2) + mbnum;
+        pp_mod[5] = pp_mod[4] + TotalMB;
+    }
+#endif
+
+    /*  oscl_memset(mblock->block, 0, sizeof(typeMBStore));    Aug 9,2005 */
+
+    if (mode & INTRA_MASK) /* MODE_INTRA || mode == MODE_INTRA_Q */
+    {
+        switched = 0;
+        if (intra_dc_vlc_thr)
+        {
+            if (video->usePrevQP)
+                QP_tmp = video->QPMB[mbnum-1];   /* running QP  04/26/01 */
+
+            switched = (intra_dc_vlc_thr == 7 || QP_tmp >= intra_dc_vlc_thr * 2 + 11);
+        }
+
+        mblock->DCScalarLum = cal_dc_scaler(QP, LUMINANCE_DC_TYPE);     /*   ACDC 03/01/01 */
+        mblock->DCScalarChr = cal_dc_scaler(QP, CHROMINANCE_DC_TYPE);
+
+        for (comp = 0; comp < 6; comp++)
+        {
+            dataBlock = mblock->block[comp];    /*, 10/20/2000 */
+
+            dataBlock[0] = (*DC)[comp];
+
+            ncoeffs[comp] = VlcDequantH263IntraBlock(video, comp,
+                            switched, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
+
+            if (VLC_ERROR_DETECTED(ncoeffs[comp]))         /*  */
+            {
+                if (switched)
+                    return PV_FAIL;
+                else
+                {
+                    ncoeffs[comp] = 1;
+                    oscl_memset((dataBlock + 1), 0, sizeof(int16)*63);
+                }
+            }
+            no_coeff[comp] = ncoeffs[comp];
+            /*  modified to new semaphore for post-proc */
+            // Future work:: can be combined in the dequant function
+            // @todo Deblocking Semaphore for INTRA block
+#ifdef PV_POSTPROC_ON
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[comp] = (uint8) PostProcSemaphore(dataBlock);
+#endif
+        }
+        MBlockIDCT(video);
+    }
+    else /* MODE INTER*/
+    {
+
+
+
+
+        MBMotionComp(video, CBP);
+        offset = (int32)(y_pos << 4) * width + (x_pos << 4);
+        c_comp  = video->currVop->yChan + offset;
+
+
+        for (comp = 0; comp < 4; comp++)
+        {
+            (*DC)[comp] = mid_gray;
+
+            if (CBP & (1 << (5 - comp)))
+            {
+                ncoeffs[comp] = VlcDequantH263InterBlock(video, comp,
+                                mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
+                if (VLC_ERROR_DETECTED(ncoeffs[comp]))
+                    return PV_FAIL;
+
+
+                BlockIDCT(c_comp + (comp&2)*(width << 2) + 8*(comp&1), mblock->pred_block + (comp&2)*64 + 8*(comp&1), mblock->block[comp], width, ncoeffs[comp],
+                          mblock->bitmapcol[comp], mblock->bitmaprow[comp]);
+
+            }
+            else
+            {
+                ncoeffs[comp] = 0;
+            }
+
+            /*  @todo Deblocking Semaphore for INTRA block, for inter just test for ringing  */
+#ifdef PV_POSTPROC_ON
+            if (video->postFilterType != PV_NO_POST_PROC)
+                *pp_mod[comp] = (uint8)((ncoeffs[comp] > 3) ? 4 : 0);
+#endif
+        }
+
+        (*DC)[4] = mid_gray;
+        if (CBP & 2)
+        {
+            ncoeffs[4] = VlcDequantH263InterBlock(video, 4,
+                                                  mblock->bitmapcol[4], &mblock->bitmaprow[4]);
+            if (VLC_ERROR_DETECTED(ncoeffs[4]))
+                return PV_FAIL;
+
+            BlockIDCT(video->currVop->uChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 256, mblock->block[4], width >> 1, ncoeffs[4],
+                      mblock->bitmapcol[4], mblock->bitmaprow[4]);
+
+        }
+        else
+        {
+            ncoeffs[4] = 0;
+        }
+#ifdef PV_POSTPROC_ON
+        if (video->postFilterType != PV_NO_POST_PROC)
+            *pp_mod[4] = (uint8)((ncoeffs[4] > 3) ? 4 : 0);
+#endif
+        (*DC)[5] = mid_gray;
+        if (CBP & 1)
+        {
+            ncoeffs[5] = VlcDequantH263InterBlock(video, 5,
+                                                  mblock->bitmapcol[5], &mblock->bitmaprow[5]);
+            if (VLC_ERROR_DETECTED(ncoeffs[5]))
+                return PV_FAIL;
+
+            BlockIDCT(video->currVop->vChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 264, mblock->block[5], width >> 1, ncoeffs[5],
+                      mblock->bitmapcol[5], mblock->bitmaprow[5]);
+
+        }
+        else
+        {
+            ncoeffs[5] = 0;
+        }
+#ifdef PV_POSTPROC_ON
+        if (video->postFilterType != PV_NO_POST_PROC)
+            *pp_mod[5] = (uint8)((ncoeffs[5] > 3) ? 4 : 0);
+#endif
+
+
+
+
+        /* Motion compensation and put it to video->mblock->pred_block */
+    }
+    return PV_SUCCESS;
+}
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/dcac_prediction.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/dcac_prediction.cpp
new file mode 100644
index 0000000..2a8bf1e
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/dcac_prediction.cpp
@@ -0,0 +1,368 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4dec_lib.h"
+#include "vlc_decode.h"
+#include "bitstream.h"
+#include "zigzag.h"
+#include "scaling.h"
+
+void    doDCACPrediction(
+    VideoDecData *video,
+    int comp,
+    int16 *q_block,
+    int *direction
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int i;
+    int mbnum = video->mbnum;
+    int nMBPerRow = video->nMBPerRow;
+    int x_pos = video->mbnum_col;
+    int y_pos = video->mbnum_row;
+    int16 *AC_tmp;
+    int QP_tmp;
+    int16 *QP_store = video->QPMB + mbnum;
+    int QP = video->QPMB[mbnum];
+    int QP_half = QP >> 1;
+    int32 val;
+    int flag_0 = FALSE, flag_1 = FALSE;
+    uint8 *slice_nb = video->sliceNo;
+    typeDCStore *DC_store = video->predDC + mbnum;
+    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
+    typeDCACStore *DCAC_col = video->predDCAC_col;
+
+    uint ACpred_flag = (uint) video->acPredFlag[mbnum];
+
+    int left_bnd, up_bnd;
+
+    static const int Xpos[6] = { -1, 0, -1, 0, -1, -1};
+    static const int Ypos[6] = { -1, -1, 0, 0, -1, -1};
+
+    static const int Xtab[6] = {1, 0, 3, 2, 4, 5};
+    static const int Ytab[6] = {2, 3, 0, 1, 4, 5};
+    static const int Ztab[6] = {3, 2, 1, 0, 4, 5};
+
+    /* I added these to speed up comparisons */
+    static const int Pos0[6] = { 1, 1, 0, 0, 1, 1};
+    static const int Pos1[6] = { 1, 0, 1, 0, 1, 1};
+
+    static const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
+    static const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
+
+//  int *direction;     /* 0: HORIZONTAL, 1: VERTICAL */
+    int block_A, block_B, block_C;
+    int DC_pred;
+    int y_offset, x_offset, x_tab, y_tab, z_tab;    /* speedup coefficients */
+    int b_xtab, b_ytab;
+
+    if (!comp && x_pos && !(video->headerInfo.Mode[mbnum-1]&INTRA_MASK)) /* not intra */
+    {
+        oscl_memset(DCAC_col, 0, sizeof(typeDCACStore));
+    }
+    if (!comp && y_pos && !(video->headerInfo.Mode[mbnum-nMBPerRow]&INTRA_MASK)) /* not intra */
+    {
+        oscl_memset(DCAC_row, 0, sizeof(typeDCACStore));
+    }
+
+    y_offset = Ypos[comp] * nMBPerRow;
+    x_offset = Xpos[comp];
+    x_tab = Xtab[comp];
+    y_tab = Ytab[comp];
+    z_tab = Ztab[comp];
+
+    b_xtab = B_Xtab[comp];
+    b_ytab = B_Ytab[comp];
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* Find the direction of prediction and the DC prediction */
+
+    if (x_pos == 0 && y_pos == 0)
+    {   /* top left corner */
+        block_A = (comp == 1 || comp == 3) ? flag_0 = TRUE, DC_store[0][x_tab] : mid_gray;
+        block_B = (comp == 3) ? DC_store[x_offset][z_tab] : mid_gray;
+        block_C = (comp == 2 || comp == 3) ? flag_1 = TRUE, DC_store[0][y_tab] : mid_gray;
+    }
+    else if (x_pos == 0)
+    {   /* left edge */
+        up_bnd   = Pos0[comp] && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow];
+
+        block_A = (comp == 1 || comp == 3) ? flag_0 = TRUE, DC_store[0][x_tab] : mid_gray;
+        block_B = ((comp == 1 && up_bnd) || comp == 3) ?  DC_store[y_offset+x_offset][z_tab] : mid_gray;
+        block_C = (comp == 2 || comp == 3 || up_bnd) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
+    }
+    else if (y_pos == 0)
+    { /* top row */
+        left_bnd = Pos1[comp] && slice_nb[mbnum] == slice_nb[mbnum-1];
+
+        block_A = (comp == 1 || comp == 3 || left_bnd) ? flag_0 = TRUE, DC_store[x_offset][x_tab] : mid_gray;
+        block_B = ((comp == 2 && left_bnd) || comp == 3) ? DC_store[y_offset + x_offset][z_tab] : mid_gray;
+        block_C = (comp == 2 || comp == 3) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
+    }
+    else
+    {
+        up_bnd   = Pos0[comp] && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow];
+        left_bnd = Pos1[comp] && slice_nb[mbnum] == slice_nb[mbnum-1];
+
+        block_A = (comp == 1 || comp == 3 || left_bnd) ? flag_0 = TRUE, DC_store[x_offset][x_tab] : mid_gray;
+        block_B = (((comp == 0 || comp == 4 || comp == 5) && slice_nb[mbnum] == slice_nb[mbnum-1-nMBPerRow]) ||
+                   (comp == 1 && up_bnd) || (comp == 2 && left_bnd) || (comp == 3)) ? DC_store[y_offset+x_offset][z_tab] : mid_gray;
+        block_C = (comp == 2 || comp == 3 || up_bnd) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
+    }
+
+
+    if ((PV_ABS((block_A - block_B))) < (PV_ABS((block_B - block_C))))
+    {
+        DC_pred = block_C;
+        *direction = 1;
+        if (ACpred_flag == 1)
+        {
+            if (flag_1)
+            {
+                AC_tmp = DCAC_row[0][b_xtab];
+                QP_tmp = QP_store[y_offset];
+                if (QP_tmp == QP)
+                {
+                    for (i = 1; i < 8; i++)
+                    {
+                        q_block[i] = *AC_tmp++;
+                    }
+                }
+                else
+                {
+                    for (i = 1; i < 8; i++)
+                    {
+                        val = (int32)(*AC_tmp++) * QP_tmp;
+                        q_block[i] = (val < 0) ? (int16)((val - QP_half) / QP) : (int16)((val + QP_half) / QP);
+                        /* Vertical, top ROW of block C */
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        DC_pred = block_A;
+        *direction = 0;
+        if (ACpred_flag == 1)
+        {
+            if (flag_0)
+            {
+                AC_tmp = DCAC_col[0][b_ytab];
+                QP_tmp = QP_store[x_offset];
+                if (QP_tmp == QP)
+                {
+                    for (i = 1; i < 8; i++)
+                    {
+                        q_block[i<<3] = *AC_tmp++;
+                    }
+                }
+                else
+                {
+                    for (i = 1; i < 8; i++)
+                    {
+                        val = (int32)(*AC_tmp++) * QP_tmp;
+                        q_block[i<<3] = (val < 0) ? (int16)((val - QP_half) / QP) : (int16)((val + QP_half) / QP);
+                        /* Vertical, top ROW of block C */
+                    }
+                }
+            }
+        }
+    }
+
+    /* Now predict the DC coefficient */
+    QP_tmp = (comp < 4) ? video->mblock->DCScalarLum : video->mblock->DCScalarChr;
+    q_block[0] += (int16)((DC_pred + (QP_tmp >> 1)) * scale[QP_tmp] >> 18);
+//      q_block[0] += (DC_pred+(QP_tmp>>1))/QP_tmp;
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+#ifdef PV_ANNEX_IJKT_SUPPORT
+void    doDCACPrediction_I(
+    VideoDecData *video,
+    int comp,
+    int16 *q_block
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int mbnum = video->mbnum;
+    int nMBPerRow = video->nMBPerRow;
+    int x_pos = video->mbnum_col;
+    int y_pos = video->mbnum_row;
+    int16 *AC_tmp;
+    int flag_0 = FALSE, flag_1 = FALSE;
+    uint8 *slice_nb = video->sliceNo;
+    typeDCStore *DC_store = video->predDC + mbnum;
+    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
+    typeDCACStore *DCAC_col = video->predDCAC_col;
+    int left_bnd, up_bnd;
+    uint8 *mode = video->headerInfo.Mode;
+    uint ACpred_flag = (uint) video->acPredFlag[mbnum];
+
+
+
+    static const int Xpos[6] = { -1, 0, -1, 0, -1, -1};
+    static const int Ypos[6] = { -1, -1, 0, 0, -1, -1};
+
+    static const int Xtab[6] = {1, 0, 3, 2, 4, 5};
+    static const int Ytab[6] = {2, 3, 0, 1, 4, 5};
+
+    /* I added these to speed up comparisons */
+    static const int Pos0[6] = { 1, 1, 0, 0, 1, 1};
+    static const int Pos1[6] = { 1, 0, 1, 0, 1, 1};
+
+    static const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
+    static const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
+
+//  int *direction;     /* 0: HORIZONTAL, 1: VERTICAL */
+    int block_A, block_C;
+    int y_offset, x_offset, x_tab, y_tab;   /* speedup coefficients */
+    int b_xtab, b_ytab;
+    y_offset = Ypos[comp] * nMBPerRow;
+    x_offset = Xpos[comp];
+    x_tab = Xtab[comp];
+    y_tab = Ytab[comp];
+
+    b_xtab = B_Xtab[comp];
+    b_ytab = B_Ytab[comp];
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* Find the direction of prediction and the DC prediction */
+
+    if (x_pos == 0 && y_pos == 0)
+    {   /* top left corner */
+        block_A = (comp == 1 || comp == 3) ? flag_0 = TRUE, DC_store[0][x_tab] : mid_gray;
+        block_C = (comp == 2 || comp == 3) ? flag_1 = TRUE, DC_store[0][y_tab] : mid_gray;
+    }
+    else if (x_pos == 0)
+    {   /* left edge */
+        up_bnd   = (Pos0[comp] && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])
+                   && (mode[mbnum-nMBPerRow] == MODE_INTRA || mode[mbnum-nMBPerRow] == MODE_INTRA_Q);;
+
+        block_A = (comp == 1 || comp == 3) ? flag_0 = TRUE, DC_store[0][x_tab] : mid_gray;
+        block_C = (comp == 2 || comp == 3 || up_bnd) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
+    }
+    else if (y_pos == 0)
+    { /* top row */
+        left_bnd = (Pos1[comp] && slice_nb[mbnum] == slice_nb[mbnum-1])
+                   && (mode[mbnum-1] == MODE_INTRA || mode[mbnum-1] == MODE_INTRA_Q);
+
+        block_A = (comp == 1 || comp == 3 || left_bnd) ? flag_0 = TRUE, DC_store[x_offset][x_tab] : mid_gray;
+        block_C = (comp == 2 || comp == 3) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
+    }
+    else
+    {
+        up_bnd   = (Pos0[comp] && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])
+                   && (mode[mbnum-nMBPerRow] == MODE_INTRA || mode[mbnum-nMBPerRow] == MODE_INTRA_Q);
+        left_bnd = (Pos1[comp] && slice_nb[mbnum] == slice_nb[mbnum-1])
+                   && (mode[mbnum-1] == MODE_INTRA || mode[mbnum-1] == MODE_INTRA_Q);
+
+        block_A = (comp == 1 || comp == 3 || left_bnd) ? flag_0 = TRUE, DC_store[x_offset][x_tab] : mid_gray;
+        block_C = (comp == 2 || comp == 3 || up_bnd) ? flag_1 = TRUE, DC_store[y_offset][y_tab] : mid_gray;
+    }
+
+    if (ACpred_flag == 0)
+    {
+        if (flag_0 == TRUE)
+        {
+            if (flag_1 == TRUE)
+            {
+                q_block[0] = (int16)((block_A + block_C) >> 1);
+            }
+            else
+            {
+                q_block[0] = (int16)block_A;
+            }
+        }
+        else
+        {
+            if (flag_1 == TRUE)
+            {
+                q_block[0] = (int16)block_C;
+            }
+            else
+            {
+                q_block[0] = mid_gray;
+            }
+        }
+
+    }
+    else
+    {
+        if (video->mblock->direction == 1)
+        {
+            if (flag_1 == TRUE)
+            {
+                q_block[0] = (int16)block_C;
+
+                AC_tmp = DCAC_row[0][b_xtab];
+                q_block[1] = AC_tmp[0];
+                q_block[2] = AC_tmp[1];
+                q_block[3] = AC_tmp[2];
+                q_block[4] = AC_tmp[3];
+                q_block[5] = AC_tmp[4];
+                q_block[6] = AC_tmp[5];
+                q_block[7] = AC_tmp[6];
+            }
+            else
+            {
+                q_block[0] = mid_gray;
+            }
+        }
+        else
+        {
+            if (flag_0 == TRUE)
+            {
+                q_block[0] = (int16)block_A;
+
+                AC_tmp = DCAC_col[0][b_ytab];
+                q_block[8] = AC_tmp[0];
+                q_block[16] = AC_tmp[1];
+                q_block[24] = AC_tmp[2];
+                q_block[32] = AC_tmp[3];
+                q_block[40] = AC_tmp[4];
+                q_block[48] = AC_tmp[5];
+                q_block[56] = AC_tmp[6];
+            }
+            else
+            {
+                q_block[0] = mid_gray;
+            }
+        }
+    }
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/dec_pred_intra_dc.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/dec_pred_intra_dc.cpp
new file mode 100644
index 0000000..c19c23a
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/dec_pred_intra_dc.cpp
@@ -0,0 +1,75 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h"
+#include "vlc_decode.h"
+#include "bitstream.h"
+#include "zigzag.h"
+
+PV_STATUS PV_DecodePredictedIntraDC(
+    int compnum,
+    BitstreamDecVideo *stream,
+    int16 *INTRADC_delta)
+{
+
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    PV_STATUS status = PV_SUCCESS;
+    uint DC_size;
+    uint code;
+    int first_bit;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* read DC size 2 - 8 bits */
+    status = PV_VlcDecIntraDCPredSize(stream, compnum, &DC_size);
+
+    if (status == PV_SUCCESS)
+    {
+        if (DC_size == 0)
+        {
+            *INTRADC_delta = 0;
+        }
+        else
+        {
+            /* read delta DC 0 - 8 bits */
+            code = (int) BitstreamReadBits16_INLINE(stream, DC_size);
+
+            first_bit = code >> (DC_size - 1);
+
+            if (first_bit == 0)
+            {
+                /* negative delta INTRA DC */
+                *INTRADC_delta = code ^((1 << DC_size) - 1);
+                *INTRADC_delta = -(*INTRADC_delta);
+            }
+            else
+            { /* positive delta INTRA DC */
+                *INTRADC_delta = code;
+            }
+            if (DC_size > 8) BitstreamRead1Bits_INLINE(stream);
+        }
+    }
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return status;
+}
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/deringing_chroma.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/deringing_chroma.cpp
new file mode 100644
index 0000000..ce779b0
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/deringing_chroma.cpp
@@ -0,0 +1,215 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include    "mp4dec_lib.h"
+#include    "post_proc.h"
+
+#ifdef PV_POSTPROC_ON
+
+void Deringing_Chroma(
+    uint8 *Rec_C,
+    int width,
+    int height,
+    int16 *QP_store,
+    int,
+    uint8 *pp_mod
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int thres;
+    int v_blk, h_blk;
+    int max_diff;
+    int v_pel, h_pel;
+    int max_blk, min_blk;
+    int v0, h0;
+    uint8 *ptr;
+    int sum, sum1, incr;
+    int32 addr_v;
+    int sign_v[10], sum_v[10];
+    int *ptr2, *ptr3;
+    uint8 pelu, pelc, pell;
+    incr = width - BLKSIZE;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* chrominance */
+    /* Do the first line (7 pixels at a time => Don't use MMX)*/
+    for (h_blk = 0; h_blk < width; h_blk += BLKSIZE)
+    {
+        max_diff = (QP_store[h_blk>>3] >> 2) + 4;
+        ptr = &Rec_C[h_blk];
+        max_blk = min_blk = *ptr;
+        FindMaxMin(ptr, &min_blk, &max_blk, width);
+        h0 = ((h_blk - 1) >= 1) ? (h_blk - 1) : 1;
+
+        if (max_blk - min_blk >= 4)
+        {
+            thres = (max_blk + min_blk + 1) >> 1;
+
+
+            for (v_pel = 1; v_pel < BLKSIZE - 1; v_pel++)
+            {
+                addr_v = (int32)v_pel * width;
+                ptr = &Rec_C[addr_v + h0 - 1];
+                ptr2 = &sum_v[0];
+                ptr3 = &sign_v[0];
+
+                pelu = *(ptr - width);
+                pelc = *ptr;
+                pell = *(ptr + width);
+                ptr++;
+                *ptr2++ = pelu + (pelc << 1) + pell;
+                *ptr3++ = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres);
+
+                pelu = *(ptr - width);
+                pelc = *ptr;
+                pell = *(ptr + width);
+                ptr++;
+                *ptr2++ = pelu + (pelc << 1) + pell;
+                *ptr3++ = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres);
+
+                for (h_pel = h0; h_pel < h_blk + BLKSIZE - 1; h_pel++)
+                {
+                    pelu = *(ptr - width);
+                    pelc = *ptr;
+                    pell = *(ptr + width);
+
+                    *ptr2 = pelu + (pelc << 1) + pell;
+                    *ptr3 = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres);
+
+                    sum1 = *(ptr3 - 2) + *(ptr3 - 1) + *ptr3;
+                    if (sum1 == 0 || sum1 == 9)
+                    {
+                        sum = (*(ptr2 - 2) + (*(ptr2 - 1) << 1) + *ptr2 + 8) >> 4;
+
+                        ptr--;
+                        if (PV_ABS(*ptr - sum) > max_diff)
+                        {
+                            if (sum > *ptr)
+                                sum = *ptr + max_diff;
+                            else
+                                sum = *ptr - max_diff;
+                        }
+                        *ptr++ = (uint8) sum;
+                    }
+                    ptr++;
+                    ptr2++;
+                    ptr3++;
+                }
+            }
+        }
+    }
+
+    for (v_blk = BLKSIZE; v_blk < height; v_blk += BLKSIZE)
+    {
+        v0 = v_blk - 1;
+        /* Do the first block (pixels=7 => No MMX) */
+        max_diff = (QP_store[((((int32)v_blk*width)>>3))>>3] >> 2) + 4;
+        ptr = &Rec_C[(int32)v_blk * width];
+        max_blk = min_blk = *ptr;
+        FindMaxMin(ptr, &min_blk, &max_blk, incr);
+
+        if (max_blk - min_blk >= 4)
+        {
+            thres = (max_blk + min_blk + 1) >> 1;
+
+            for (v_pel = v0; v_pel < v_blk + BLKSIZE - 1; v_pel++)
+            {
+                addr_v = v_pel * width;
+                ptr = &Rec_C[addr_v];
+                ptr2 = &sum_v[0];
+                ptr3 = &sign_v[0];
+
+                pelu = *(ptr - width);
+                pelc = *ptr;
+                pell = *(ptr + width);
+                ptr++;
+                *ptr2++ = pelu + (pelc << 1) + pell;
+                *ptr3++ = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres);
+
+                pelu = *(ptr - width);
+                pelc = *ptr;
+                pell = *(ptr + width);
+                ptr++;
+                *ptr2++ = pelu + (pelc << 1) + pell;
+                *ptr3++ = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres);
+
+                for (h_pel = 1; h_pel < BLKSIZE - 1; h_pel++)
+                {
+                    pelu = *(ptr - width);
+                    pelc = *ptr;
+                    pell = *(ptr + width);
+
+                    *ptr2 = pelu + (pelc << 1) + pell;
+                    *ptr3 = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres);
+
+                    sum1 = *(ptr3 - 2) + *(ptr3 - 1) + *ptr3;
+                    if (sum1 == 0 || sum1 == 9)
+                    {
+                        sum = (*(ptr2 - 2) + (*(ptr2 - 1) << 1) + *ptr2 + 8) >> 4;
+
+                        ptr--;
+                        if (PV_ABS(*ptr - sum) > max_diff)
+                        {
+                            if (sum > *ptr)
+                                sum = *ptr + max_diff;
+                            else
+                                sum = *ptr - max_diff;
+                        }
+                        *ptr++ = (uint8) sum;
+                    }
+                    ptr++;
+                    ptr2++;
+                    ptr3++;
+                }
+            }
+        }
+
+
+        /* Do the rest in MMX */
+        for (h_blk = BLKSIZE; h_blk < width; h_blk += BLKSIZE)
+        {
+            if ((pp_mod[(v_blk/8)*(width/8)+h_blk/8]&0x4) != 0)
+            {
+                max_diff = (QP_store[((((int32)v_blk*width)>>3)+h_blk)>>3] >> 2) + 4;
+                ptr = &Rec_C[(int32)v_blk * width + h_blk];
+                max_blk = min_blk = *ptr;
+                FindMaxMin(ptr, &min_blk, &max_blk, incr);
+                h0 = h_blk - 1;
+
+                if (max_blk - min_blk >= 4)
+                {
+                    thres = (max_blk + min_blk + 1) >> 1;
+#ifdef NoMMX
+                    AdaptiveSmooth_NoMMX(Rec_C, v0, h0, v_blk, h_blk, thres, width, max_diff);
+#else
+                    DeringAdaptiveSmoothMMX(&Rec_C[(int32)v0*width+h0], width, thres, max_diff);
+#endif
+                }
+            }
+        }
+    } /* macroblock level */
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/deringing_luma.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/deringing_luma.cpp
new file mode 100644
index 0000000..b5574b4
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/deringing_luma.cpp
@@ -0,0 +1,231 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include    "mp4dec_lib.h"
+#include    "post_proc.h"
+
+#ifdef PV_POSTPROC_ON
+
+void Deringing_Luma(
+    uint8 *Rec_Y,
+    int width,
+    int height,
+    int16 *QP_store,
+    int,
+    uint8 *pp_mod)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int thres[4], range[4], max_range_blk, max_thres_blk;
+    int MB_V, MB_H, BLK_V, BLK_H;
+    int v_blk, h_blk;
+    int max_diff;
+    int max_blk, min_blk;
+    int v0, h0;
+    uint8 *ptr;
+    int thr, blks, incr;
+    int mb_indx, blk_indx;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    incr = width - BLKSIZE;
+
+    /* Dering the first line of macro blocks */
+    for (MB_H = 0; MB_H < width; MB_H += MBSIZE)
+    {
+        max_diff = (QP_store[(MB_H)>>4] >> 2) + 4;
+
+        /* threshold determination */
+        max_range_blk = max_thres_blk = 0;
+        blks = 0;
+
+        for (BLK_V = 0; BLK_V < MBSIZE; BLK_V += BLKSIZE)
+        {
+            for (BLK_H = 0; BLK_H < MBSIZE; BLK_H += BLKSIZE)
+            {
+                ptr = &Rec_Y[(int32)(BLK_V) * width + MB_H + BLK_H];
+                FindMaxMin(ptr, &min_blk, &max_blk, incr);
+
+                thres[blks] = (max_blk + min_blk + 1) >> 1;
+                range[blks] = max_blk - min_blk;
+
+                if (range[blks] >= max_range_blk)
+                {
+                    max_range_blk = range[blks];
+                    max_thres_blk = thres[blks];
+                }
+                blks++;
+            }
+        }
+
+        blks = 0;
+        for (v_blk = 0; v_blk < MBSIZE; v_blk += BLKSIZE)
+        {
+            v0 = ((v_blk - 1) >= 1) ? (v_blk - 1) : 1;
+            for (h_blk = MB_H; h_blk < MB_H + MBSIZE; h_blk += BLKSIZE)
+            {
+                h0 = ((h_blk - 1) >= 1) ? (h_blk - 1) : 1;
+
+                /* threshold rearrangement for flat region adjacent to non-flat region */
+                if (range[blks]<32 && max_range_blk >= 64)
+                    thres[blks] = max_thres_blk;
+
+                /* threshold rearrangement for deblocking
+                (blockiness annoying at DC dominant region) */
+                if (max_range_blk >= 16)
+                {
+                    /* adaptive smoothing */
+                    thr = thres[blks];
+
+                    AdaptiveSmooth_NoMMX(Rec_Y, v0, h0, v_blk, h_blk,
+                                         thr, width, max_diff);
+                }
+                blks++;
+            } /* block level (Luminance) */
+        }
+    } /* macroblock level */
+
+
+    /* Do the rest of the macro-block-lines */
+    for (MB_V = MBSIZE; MB_V < height; MB_V += MBSIZE)
+    {
+        /* First macro-block */
+        max_diff = (QP_store[((((int32)MB_V*width)>>4))>>4] >> 2) + 4;
+        /* threshold determination */
+        max_range_blk = max_thres_blk = 0;
+        blks = 0;
+        for (BLK_V = 0; BLK_V < MBSIZE; BLK_V += BLKSIZE)
+        {
+            for (BLK_H = 0; BLK_H < MBSIZE; BLK_H += BLKSIZE)
+            {
+                ptr = &Rec_Y[(int32)(MB_V + BLK_V) * width + BLK_H];
+                FindMaxMin(ptr, &min_blk, &max_blk, incr);
+                thres[blks] = (max_blk + min_blk + 1) >> 1;
+                range[blks] = max_blk - min_blk;
+
+                if (range[blks] >= max_range_blk)
+                {
+                    max_range_blk = range[blks];
+                    max_thres_blk = thres[blks];
+                }
+                blks++;
+            }
+        }
+
+        blks = 0;
+        for (v_blk = MB_V; v_blk < MB_V + MBSIZE; v_blk += BLKSIZE)
+        {
+            v0 = v_blk - 1;
+            for (h_blk = 0; h_blk < MBSIZE; h_blk += BLKSIZE)
+            {
+                h0 = ((h_blk - 1) >= 1) ? (h_blk - 1) : 1;
+
+                /* threshold rearrangement for flat region adjacent to non-flat region */
+                if (range[blks]<32 && max_range_blk >= 64)
+                    thres[blks] = max_thres_blk;
+
+                /* threshold rearrangement for deblocking
+                (blockiness annoying at DC dominant region) */
+                if (max_range_blk >= 16)
+                {
+                    /* adaptive smoothing */
+                    thr = thres[blks];
+
+                    AdaptiveSmooth_NoMMX(Rec_Y, v0, h0, v_blk, h_blk,
+                                         thr, width, max_diff);
+                }
+                blks++;
+            }
+        } /* block level (Luminance) */
+
+        /* Rest of the macro-blocks */
+        for (MB_H = MBSIZE; MB_H < width; MB_H += MBSIZE)
+        {
+            max_diff = (QP_store[((((int32)MB_V*width)>>4)+MB_H)>>4] >> 2) + 4;
+
+            /* threshold determination */
+            max_range_blk = max_thres_blk = 0;
+            blks = 0;
+
+            mb_indx = (MB_V / 8) * (width / 8) + MB_H / 8;
+            for (BLK_V = 0; BLK_V < MBSIZE; BLK_V += BLKSIZE)
+            {
+                for (BLK_H = 0; BLK_H < MBSIZE; BLK_H += BLKSIZE)
+                {
+                    blk_indx = mb_indx + (BLK_V / 8) * width / 8 + BLK_H / 8;
+                    /* Update based on pp_mod only */
+                    if ((pp_mod[blk_indx]&0x4) != 0)
+                    {
+                        ptr = &Rec_Y[(int32)(MB_V + BLK_V) * width + MB_H + BLK_H];
+                        FindMaxMin(ptr, &min_blk, &max_blk, incr);
+                        thres[blks] = (max_blk + min_blk + 1) >> 1;
+                        range[blks] = max_blk - min_blk;
+
+                        if (range[blks] >= max_range_blk)
+                        {
+                            max_range_blk = range[blks];
+                            max_thres_blk = thres[blks];
+                        }
+                    }
+                    blks++;
+                }
+            }
+
+            blks = 0;
+            for (v_blk = MB_V; v_blk < MB_V + MBSIZE; v_blk += BLKSIZE)
+            {
+                v0 = v_blk - 1;
+                mb_indx = (v_blk / 8) * (width / 8);
+                for (h_blk = MB_H; h_blk < MB_H + MBSIZE; h_blk += BLKSIZE)
+                {
+                    h0 = h_blk - 1;
+                    blk_indx = mb_indx + h_blk / 8;
+                    if ((pp_mod[blk_indx]&0x4) != 0)
+                    {
+                        /* threshold rearrangement for flat region adjacent to non-flat region */
+                        if (range[blks]<32 && max_range_blk >= 64)
+                            thres[blks] = max_thres_blk;
+
+                        /* threshold rearrangement for deblocking
+                        (blockiness annoying at DC dominant region) */
+                        if (max_range_blk >= 16)
+                        {
+                            /* adaptive smoothing */
+                            thr = thres[blks];
+#ifdef NoMMX
+                            AdaptiveSmooth_NoMMX(Rec_Y, v0, h0, v_blk, h_blk,
+                                                 thr, width, max_diff);
+#else
+                            DeringAdaptiveSmoothMMX(&Rec_Y[v0*width+h0],
+                                                    width, thr, max_diff);
+#endif
+                        }
+                    }
+                    blks++;
+                }
+            } /* block level (Luminance) */
+        } /* macroblock level */
+    } /* macroblock level */
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/find_min_max.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/find_min_max.cpp
new file mode 100644
index 0000000..a357ea6
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/find_min_max.cpp
@@ -0,0 +1,176 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    input_ptr = pointer to the buffer containing values of type UChar
+            in a 2D block of data.
+    min_ptr = pointer to the minimum value of type Int to be found in a
+          square block of size BLKSIZE contained in 2D block of data.
+    max_ptr = pointer to the maximum value of type Int to be found in a
+          square block of size BLKSIZE contained in 2D block of data.
+    incr = value of type Int representing the width of 2D block of data.
+
+ Local Stores/Buffers/Pointers Needed:
+    None
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Outputs:
+    None
+
+ Pointers and Buffers Modified:
+    min_ptr points to the found minimum value in the square block of
+    size BLKSIZE contained in 2D block of data.
+
+    max_ptr points to the found maximum value in the square block of
+    size BLKSIZE contained in 2D block of data.
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ This function finds the maximum and the minimum values in a square block of
+ data of size BLKSIZE * BLKSIZE. The data is contained in the buffer which
+ represents a 2D block of data that is larger than BLKSIZE * BLKSIZE.
+ This is illustrated below.
+
+    mem loc x + 00h -> o o o o o o o o o o o o o o o o
+    mem loc x + 10h -> o o o o o X X X X X X X X o o o
+    mem loc x + 20h -> o o o o o X X X X X X X X o o o
+    mem loc x + 30h -> o o o o o X X X X X X X X o o o
+    mem loc x + 40h -> o o o o o X X X X X X X X o o o
+    mem loc x + 50h -> o o o o o X X X X X X X X o o o
+    mem loc x + 60h -> o o o o o X X X X X X X X o o o
+    mem loc x + 70h -> o o o o o X X X X X X X X o o o
+    mem loc x + 80h -> o o o o o X X X X X X X X o o o
+    mem loc x + 90h -> o o o o o o o o o o o o o o o o
+    mem loc x + A0h -> o o o o o o o o o o o o o o o o
+    mem loc x + B0h -> o o o o o o o o o o o o o o o o
+
+For illustration purposes, the diagram assumes that BLKSIZE is equal to 8
+but this is not a requirement. In this diagram, the buffer starts at
+location x but the input pointer, input_ptr, passed into this function
+would be the first row of data to be searched which is at x + 15h. The
+value of incr passed onto this function represents the amount the input_ptr
+needs to be incremented to point to the next row of data.
+
+This function compares each value in a row to the current maximum and
+minimum. After each row, input_ptr is incremented to point to the next row.
+This is repeated until all rows have been processed. When the search is
+complete the location pointed to by min_ptr contains the minimum value
+found and the location pointed to by max_ptr contains the maximum value found.
+
+------------------------------------------------------------------------------
+*/
+
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include    "mp4dec_lib.h"
+#include    "post_proc.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+#ifdef PV_POSTPROC_ON
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+void  FindMaxMin(
+    uint8 *input_ptr,
+    int *min_ptr,
+    int *max_ptr,
+    int incr)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    register    uint    i, j;
+    register    int min, max;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    max = min = *input_ptr;
+    /*  incr = incr - BLKSIZE; */   /*  09/06/2001, already passed in as width - BLKSIZE */
+
+    for (i = BLKSIZE; i > 0; i--)
+    {
+        for (j = BLKSIZE; j > 0; j--)
+        {
+            if (*input_ptr > max)
+            {
+                max = *input_ptr;
+            }
+            else if (*input_ptr < min)
+            {
+                min = *input_ptr;
+            }
+            input_ptr += 1;
+        }
+
+        /* set pointer to the beginning of the next row*/
+        input_ptr += incr;
+    }
+
+    *max_ptr = max;
+    *min_ptr = min;
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/get_pred_adv_b_add.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/get_pred_adv_b_add.cpp
new file mode 100644
index 0000000..e23f23d
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/get_pred_adv_b_add.cpp
@@ -0,0 +1,1190 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    xpos = x half-pixel of (x,y) coordinates within a VOP; motion
+           compensated coordinates; native type
+    ypos = y half-pixel of (x,y) coordinates within a VOP; motion
+           compensated coordinates; native type
+    comp = pointer to 8-bit compensated prediction values within a VOP;
+        computed by this module (i/o); full-pel resolution
+    c_prev = pointer to previous 8-bit prediction values within a VOP;
+          values range from (0-255); full-pel resolution
+    sh_d = pointer to residual values used to compensate the predicted
+        value; values range from (-512 to 511); full-pel resolution
+    width = width of the VOP in pixels (x axis); full-pel resolution
+    rnd1 = rounding value for case when one dimension uses half-pel
+           resolution
+    rnd2 = rounding value for case when two dimensions uses half-pel
+           resolution
+    CBP = flag indicating whether residual is all zeros
+          (0 -> all zeros, 1 -> not all zeros)
+        outside_flag = flag indicating whether motion vector is outside the
+               VOP (0 -> inside, 1 -> outside)
+
+ Outputs:
+    returns 1
+
+ Local Stores/Buffers/Pointers Needed:
+    None
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Pointers and Buffers Modified:
+    comp = buffer contains newly computed compensated prediction values
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ Compute pixel values for a block in the current VOP. The prediction
+ values are generated by averaging pixel values in the previous VOP; the
+ block position in the previous frame is computed from the current block's
+ motion vector. The computed pixel values are then computed by adding the
+ prediction values to the block residual values.
+
+
+------------------------------------------------------------------------------
+*/
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4dec_lib.h"
+#include "motion_comp.h"
+
+#define OSCL_DISABLE_WARNING_CONV_POSSIBLE_LOSS_OF_DATA
+
+int GetPredAdvancedBy0x0(
+    uint8 *prev,        /* i */
+    uint8 *pred_block,      /* i */
+    int width,      /* i */
+    int pred_width_rnd /* i */
+)
+{
+    uint    i;      /* loop variable */
+    int offset, offset2;
+    uint32  pred_word, word1, word2;
+    int tmp;
+
+    /* initialize offset to adjust pixel counter */
+    /*    the next row; full-pel resolution      */
+    offset = width - B_SIZE; /* offset for prev */
+    offset2 = (pred_width_rnd >> 1) - 4; /* offset for pred_block */
+
+    tmp = (uint32)prev & 0x3;
+    pred_block -= offset2; /* preset */
+
+    if (tmp == 0)  /* word-aligned */
+    {
+        for (i = B_SIZE; i > 0; i--)
+        {
+            *((uint32*)(pred_block += offset2)) = *((uint32*)prev);
+            *((uint32*)(pred_block += 4)) = *((uint32*)(prev + 4));
+            prev += width;
+        }
+        return 1;
+    }
+    else if (tmp == 1) /* first position */
+    {
+        prev--; /* word-aligned */
+
+        for (i = B_SIZE; i > 0; i--)
+        {
+            word1 = *((uint32*)prev); /* read 4 bytes, b4 b3 b2 b1 */
+            word2 = *((uint32*)(prev += 4));  /* read 4 bytes, b8 b7 b6 b5 */
+            word1 >>= 8; /* 0 b4 b3 b2 */
+            pred_word = word1 | (word2 << 24);  /* b5 b4 b3 b2 */
+            *((uint32*)(pred_block += offset2)) = pred_word;
+
+            word1 = *((uint32*)(prev += 4)); /* b12 b11 b10 b9 */
+            word2 >>= 8; /* 0 b8 b7 b6 */
+            pred_word = word2 | (word1 << 24); /* b9 b8 b7 b6 */
+            *((uint32*)(pred_block += 4)) = pred_word;
+
+            prev += offset;
+        }
+
+        return 1;
+    }
+    else if (tmp == 2) /* second position */
+    {
+        prev -= 2; /* word1-aligned */
+
+        for (i = B_SIZE; i > 0; i--)
+        {
+            word1 = *((uint32*)prev); /* read 4 bytes, b4 b3 b2 b1 */
+            word2 = *((uint32*)(prev += 4));  /* read 4 bytes, b8 b7 b6 b5 */
+            word1 >>= 16; /* 0 0 b4 b3 */
+            pred_word = word1 | (word2 << 16);  /* b6 b5 b4 b3 */
+            *((uint32*)(pred_block += offset2)) = pred_word;
+
+            word1 = *((uint32*)(prev += 4)); /* b12 b11 b10 b9 */
+            word2 >>= 16; /* 0 0 b8 b7 */
+            pred_word = word2 | (word1 << 16); /* b10 b9 b8 b7 */
+            *((uint32*)(pred_block += 4)) = pred_word;
+
+
+            prev += offset;
+        }
+
+        return 1;
+    }
+    else /* third position */
+    {
+        prev -= 3; /* word1-aligned */
+
+        for (i = B_SIZE; i > 0; i--)
+        {
+            word1 = *((uint32*)prev); /* read 4 bytes, b4 b3 b2 b1 */
+            word2 = *((uint32*)(prev += 4));  /* read 4 bytes, b8 b7 b6 b5 */
+            word1 >>= 24; /* 0 0 0 b4 */
+            pred_word = word1 | (word2 << 8);   /* b7 b6 b5 b4 */
+            *((uint32*)(pred_block += offset2)) = pred_word;
+
+            word1 = *((uint32*)(prev += 4)); /* b12 b11 b10 b9 */
+            word2 >>= 24; /* 0 0 0 b8 */
+            pred_word = word2 | (word1 << 8); /* b11 b10 b9 b8 */
+            *((uint32*)(pred_block += 4)) = pred_word;
+
+            prev += offset;
+        }
+
+        return 1;
+    }
+}
+
+/**************************************************************************/
+int GetPredAdvancedBy0x1(
+    uint8 *prev,        /* i */
+    uint8 *pred_block,      /* i */
+    int width,      /* i */
+    int pred_width_rnd /* i */
+)
+{
+    uint    i;      /* loop variable */
+    int offset, offset2;
+    uint32 word1, word2, word3, word12;
+    int tmp;
+    int rnd1;
+    uint32 mask;
+
+    /* initialize offset to adjust pixel counter */
+    /*    the next row; full-pel resolution      */
+    offset = width - B_SIZE; /* offset for prev */
+    offset2 = (pred_width_rnd >> 1) - 4; /* offset of pred_block */
+
+    rnd1 = pred_width_rnd & 1;
+
+    /* Branch based on pixel location (half-pel or full-pel) for x and y */
+    pred_block -= offset2; /* preset */
+
+    tmp = (uint32)prev & 3;
+    mask = 254;
+    mask |= (mask << 8);
+    mask |= (mask << 16); /* 0xFEFEFEFE */
+
+    if (tmp == 0) /* word-aligned */
+    {
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)prev); /* b4 b3 b2 b1 */
+                word2 = *((uint32*)(prev += 4)); /* b8 b7 b6 b5 */
+                word12 = (word1 >> 8); /* 0 b4 b3 b2 */
+                word12 |= (word2 << 24); /* b5 b4 b3 b2 */
+                word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1; /* write 4 pixels */
+
+                word1 = *((uint32*)(prev += 4)); /* b12 b11 b10 b9 */
+                word12 = (word2 >> 8); /* 0 b8 b7 b6 */
+                word12 |= (word1 << 24); /* b9 b8 b7 b6 */
+                word3 = word2 | word12;
+                word2 &= mask;
+                word3 &= (~mask);  /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((uint32*)(pred_block += 4)) = word2; /* write 4 pixels */
+
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 == 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)prev); /* b4 b3 b2 b1 */
+
+                word2 = *((uint32*)(prev += 4)); /* b8 b7 b6 b5 */
+                word12 = (word1 >> 8); /* 0 b4 b3 b2 */
+                word12 |= (word2 << 24); /* b5 b4 b3 b2 */
+                word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1; /* write 4 pixels */
+
+                word1 = *((uint32*)(prev += 4)); /* b12 b11 b10 b9 */
+                word12 = (word2 >> 8); /* 0 b8 b7 b6 */
+                word12 |= (word1 << 24); /* b9 b8 b7 b6 */
+                word3 = word2 & word12;
+                word2 &= mask;
+                word3 &= (~mask);  /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((uint32*)(pred_block += 4)) = word2; /* write 4 pixels */
+
+                prev += offset;
+            }
+            return 1;
+        } /* rnd1 */
+    }
+    else if (tmp == 1)
+    {
+        prev--; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)prev); /* b3 b2 b1 b0 */
+                word2 = *((uint32*)(prev += 4)); /* b7 b6 b5 b4 */
+                word12 = (word1 >> 8); /* 0 b3 b2 b1 */
+                word1 >>= 16; /* 0 0 b3 b2 */
+                word12 |= (word2 << 24); /* b4 b3 b2 b1 */
+                word1 |= (word2 << 16); /* b5 b4 b3 b2 */
+                word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1; /* write 4 pixels */
+
+                word1 = *((uint32*)(prev += 4)); /* b11 b10 b9 b8 */
+                word12 = (word2 >> 8); /* 0 b7 b6 b5 */
+                word2 >>= 16; /* 0 0 b7 b6 */
+                word12 |= (word1 << 24); /* b8 b7 b6 b5 */
+                word2 |= (word1 << 16); /* b9 b8 b7 b6 */
+                word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word2&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((uint32*)(pred_block += 4)) = word2; /* write 4 pixels */
+
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)prev); /* b3 b2 b1 b0 */
+
+                word2 = *((uint32*)(prev += 4)); /* b7 b6 b5 b4 */
+                word12 = (word1 >> 8); /* 0 b3 b2 b1 */
+                word1 >>= 16; /* 0 0 b3 b2 */
+                word12 |= (word2 << 24); /* b4 b3 b2 b1 */
+                word1 |= (word2 << 16); /* b5 b4 b3 b2 */
+                word3 = word1 & word12;
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1; /* write 4 pixels */
+
+                word1 = *((uint32*)(prev += 4)); /* b11 b10 b9 b8 */
+                word12 = (word2 >> 8); /* 0 b7 b6 b5 */
+                word2 >>= 16; /* 0 0 b7 b6 */
+                word12 |= (word1 << 24); /* b8 b7 b6 b5 */
+                word2 |= (word1 << 16); /* b9 b8 b7 b6 */
+                word3 = word2 & word12;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((uint32*)(pred_block += 4)) = word2; /* write 4 pixels */
+
+                prev += offset;
+            }
+            return 1;
+        } /* rnd1 */
+    }
+    else if (tmp == 2)
+    {
+        prev -= 2; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)prev); /* b2 b1 b0 bN1 */
+                word2 = *((uint32*)(prev += 4)); /* b6 b5 b4 b3 */
+                word12 = (word1 >> 16); /* 0 0 b2 b1 */
+                word1 >>= 24; /* 0 0 0 b2 */
+                word12 |= (word2 << 16); /* b4 b3 b2 b1 */
+                word1 |= (word2 << 8); /* b5 b4 b3 b2 */
+                word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1; /* write 4 pixels */
+
+                word1 = *((uint32*)(prev += 4)); /* b10 b9 b8 b7 */
+                word12 = (word2 >> 16); /* 0 0 b6 b5 */
+                word2 >>= 24; /* 0 0 0 b6 */
+                word12 |= (word1 << 16); /* b8 b7 b6 b5 */
+                word2 |= (word1 << 8); /* b9 b8 b7 b6 */
+                word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((uint32*)(pred_block += 4)) = word2; /* write 4 pixels */
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 == 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)prev); /* b2 b1 b0 bN1 */
+                word2 = *((uint32*)(prev += 4)); /* b6 b5 b4 b3 */
+                word12 = (word1 >> 16); /* 0 0 b2 b1 */
+                word1 >>= 24; /* 0 0 0 b2 */
+                word12 |= (word2 << 16); /* b4 b3 b2 b1 */
+                word1 |= (word2 << 8); /* b5 b4 b3 b2 */
+                word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1; /* write 4 pixels */
+
+                word1 = *((uint32*)(prev += 4)); /* b10 b9 b8 b7 */
+                word12 = (word2 >> 16); /* 0 0 b6 b5 */
+                word2 >>= 24; /* 0 0 0 b6 */
+                word12 |= (word1 << 16); /* b8 b7 b6 b5 */
+                word2 |= (word1 << 8); /* b9 b8 b7 b6 */
+                word3 = word2 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((uint32*)(pred_block += 4)) = word2; /* write 4 pixels */
+                prev += offset;
+            }
+            return 1;
+        }
+    }
+    else /* tmp = 3 */
+    {
+        prev -= 3; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)prev); /* b1 b0 bN1 bN2 */
+                word2 = *((uint32*)(prev += 4)); /* b5 b4 b3 b2 */
+                word12 = (word1 >> 24); /* 0 0 0 b1 */
+                word12 |= (word2 << 8); /* b4 b3 b2 b1 */
+                word1 = word2;
+                word3 = word1 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1; /* write 4 pixels */
+
+                word1 = *((uint32*)(prev += 4)); /* b9 b8 b7 b6 */
+                word12 = (word2 >> 24); /* 0 0 0 b5 */
+                word12 |= (word1 << 8); /* b8 b7 b6 b5 */
+                word2 = word1; /* b9 b8 b7 b6 */
+                word3 = word2 | word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((uint32*)(pred_block += 4)) = word2; /* write 4 pixels */
+                prev += offset;
+            }
+            return 1;
+        }
+        else
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)prev); /* b1 b0 bN1 bN2 */
+                word2 = *((uint32*)(prev += 4)); /* b5 b4 b3 b2 */
+                word12 = (word1 >> 24); /* 0 0 0 b1 */
+                word12 |= (word2 << 8); /* b4 b3 b2 b1 */
+                word1 = word2;
+                word3 = word1 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word12 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1; /* write 4 pixels */
+
+                word1 = *((uint32*)(prev += 4)); /* b9 b8 b7 b6 */
+                word12 = (word2 >> 24); /* 0 0 0 b5 */
+                word12 |= (word1 << 8); /* b8 b7 b6 b5 */
+                word2 = word1; /* b9 b8 b7 b6 */
+                word3 = word2 & word12; // rnd1 = 1; otherwise word3 = word1&word12
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 &= mask;
+                word2 >>= 1;
+                word2 = word2 + (word12 >> 1);
+                word2 += word3;
+                *((uint32*)(pred_block += 4)) = word2; /* write 4 pixels */
+                prev += offset;
+            }
+            return 1;
+        }
+    }
+}
+
+/**************************************************************************/
+int GetPredAdvancedBy1x0(
+    uint8 *prev,        /* i */
+    uint8 *pred_block,      /* i */
+    int width,      /* i */
+    int pred_width_rnd /* i */
+)
+{
+    uint    i;      /* loop variable */
+    int offset, offset2;
+    uint32  word1, word2, word3, word12, word22;
+    int tmp;
+    int rnd1;
+    uint32 mask;
+
+    /* initialize offset to adjust pixel counter */
+    /*    the next row; full-pel resolution      */
+    offset = width - B_SIZE; /* offset for prev */
+    offset2 = (pred_width_rnd >> 1) - 4; /* offset for pred_block */
+
+    rnd1 = pred_width_rnd & 1;
+
+    /* Branch based on pixel location (half-pel or full-pel) for x and y */
+    pred_block -= offset2; /* preset */
+
+    tmp = (uint32)prev & 3;
+    mask = 254;
+    mask |= (mask << 8);
+    mask |= (mask << 16); /* 0xFEFEFEFE */
+
+    if (tmp == 0) /* word-aligned */
+    {
+        prev -= 4;
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)(prev += 4));
+                word2 = *((uint32*)(prev + width));
+                word3 = word1 | word2; // rnd1 = 1; otherwise word3 = word1&word2
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word2 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1;
+                word1 = *((uint32*)(prev += 4));
+                word2 = *((uint32*)(prev + width));
+                word3 = word1 | word2; // rnd1 = 1; otherwise word3 = word1&word2
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word2 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += 4)) = word1;
+
+                prev += offset;
+            }
+            return 1;
+        }
+        else   /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word1 = *((uint32*)(prev += 4));
+                word2 = *((uint32*)(prev + width));
+                word3 = word1 & word2;  /* rnd1 = 0; */
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word2 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += offset2)) = word1;
+                word1 = *((uint32*)(prev += 4));
+                word2 = *((uint32*)(prev + width));
+                word3 = word1 & word2;  /* rnd1 = 0; */
+                word1 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word2 &= mask;
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += 4)) = word1;
+
+                prev += offset;
+            }
+            return 1;
+        }
+    }
+    else if (tmp == 1)
+    {
+        prev--; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((uint32*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((uint32*)(prev + width));
+
+                word1 = *((uint32*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((uint32*)(prev + width));
+                word12 >>= 8; /* 0 b4 b3 b2 */
+                word22 >>= 8;
+                word12 = word12 | (word1 << 24); /* b5 b4 b3 b2 */
+                word22 = word22 | (word2 << 24);
+                word3 = word12 | word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((uint32*)(pred_block += offset2)) = word12;
+
+                word12 = *((uint32*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((uint32*)(prev + width));
+                word1 >>= 8; /* 0 b8 b7 b6 */
+                word2 >>= 8;
+                word1 = word1 | (word12 << 24); /* b9 b8 b7 b6 */
+                word2 = word2 | (word22 << 24);
+                word3 = word1 | word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((uint32*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((uint32*)(prev + width));
+
+                word1 = *((uint32*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((uint32*)(prev + width));
+                word12 >>= 8; /* 0 b4 b3 b2 */
+                word22 >>= 8;
+                word12 = word12 | (word1 << 24); /* b5 b4 b3 b2 */
+                word22 = word22 | (word2 << 24);
+                word3 = word12 & word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((uint32*)(pred_block += offset2)) = word12;
+
+                word12 = *((uint32*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((uint32*)(prev + width));
+                word1 >>= 8; /* 0 b8 b7 b6 */
+                word2 >>= 8;
+                word1 = word1 | (word12 << 24); /* b9 b8 b7 b6 */
+                word2 = word2 | (word22 << 24);
+                word3 = word1 & word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        }
+    }
+    else if (tmp == 2)
+    {
+        prev -= 2; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((uint32*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((uint32*)(prev + width));
+
+                word1 = *((uint32*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((uint32*)(prev + width));
+                word12 >>= 16; /* 0 0 b4 b3 */
+                word22 >>= 16;
+                word12 = word12 | (word1 << 16); /* b6 b5 b4 b3 */
+                word22 = word22 | (word2 << 16);
+                word3 = word12 | word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((uint32*)(pred_block += offset2)) = word12;
+
+                word12 = *((uint32*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((uint32*)(prev + width));
+                word1 >>= 16; /* 0 0 b8 b7 */
+                word2 >>= 16;
+                word1 = word1 | (word12 << 16); /* b10 b9 b8 b7 */
+                word2 = word2 | (word22 << 16);
+                word3 = word1 | word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((uint32*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((uint32*)(prev + width));
+
+                word1 = *((uint32*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((uint32*)(prev + width));
+                word12 >>= 16; /* 0 0 b4 b3 */
+                word22 >>= 16;
+                word12 = word12 | (word1 << 16); /* b6 b5 b4 b3 */
+                word22 = word22 | (word2 << 16);
+                word3 = word12 & word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((uint32*)(pred_block += offset2)) = word12;
+
+                word12 = *((uint32*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((uint32*)(prev + width));
+                word1 >>= 16; /* 0 0 b8 b7 */
+                word2 >>= 16;
+                word1 = word1 | (word12 << 16); /* b10 b9 b8 b7 */
+                word2 = word2 | (word22 << 16);
+                word3 = word1 & word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += 4)) = word1;
+                prev += offset;
+            }
+
+            return 1;
+        }
+    }
+    else /* tmp == 3 */
+    {
+        prev -= 3; /* word-aligned */
+        if (rnd1 == 1)
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((uint32*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((uint32*)(prev + width));
+
+                word1 = *((uint32*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((uint32*)(prev + width));
+                word12 >>= 24; /* 0 0 0 b4 */
+                word22 >>= 24;
+                word12 = word12 | (word1 << 8); /* b7 b6 b5 b4 */
+                word22 = word22 | (word2 << 8);
+                word3 = word12 | word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((uint32*)(pred_block += offset2)) = word12;
+
+                word12 = *((uint32*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((uint32*)(prev + width));
+                word1 >>= 24; /* 0 0 0 b8 */
+                word2 >>= 24;
+                word1 = word1 | (word12 << 8); /* b11 b10 b9 b8 */
+                word2 = word2 | (word22 << 8);
+                word3 = word1 | word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        }
+        else /* rnd1 = 0 */
+        {
+            for (i = B_SIZE; i > 0; i--)
+            {
+                word12 = *((uint32*)prev); /* read b4 b3 b2 b1 */
+                word22 = *((uint32*)(prev + width));
+
+                word1 = *((uint32*)(prev += 4)); /* read b8 b7 b6 b5 */
+                word2 = *((uint32*)(prev + width));
+                word12 >>= 24; /* 0 0 0 b4 */
+                word22 >>= 24;
+                word12 = word12 | (word1 << 8); /* b7 b6 b5 b4 */
+                word22 = word22 | (word2 << 8);
+                word3 = word12 & word22;
+                word12 &= mask;
+                word22 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word12 >>= 1;
+                word12 = word12 + (word22 >> 1);
+                word12 += word3;
+                *((uint32*)(pred_block += offset2)) = word12;
+
+                word12 = *((uint32*)(prev += 4)); /* read b12 b11 b10 b9 */
+                word22 = *((uint32*)(prev + width));
+                word1 >>= 24; /* 0 0 0 b8 */
+                word2 >>= 24;
+                word1 = word1 | (word12 << 8); /* b11 b10 b9 b8 */
+                word2 = word2 | (word22 << 8);
+                word3 = word1 & word2;
+                word1 &= mask;
+                word2 &= mask;
+                word3 &= (~mask); /* 0x1010101, check last bit */
+                word1 >>= 1;
+                word1 = word1 + (word2 >> 1);
+                word1 += word3;
+                *((uint32*)(pred_block += 4)) = word1;
+                prev += offset;
+            }
+            return 1;
+        } /* rnd */
+    } /* tmp */
+}
+
+/**********************************************************************************/
+int GetPredAdvancedBy1x1(
+    uint8 *prev,        /* i */
+    uint8 *pred_block,      /* i */
+    int width,      /* i */
+    int pred_width_rnd /* i */
+)
+{
+    uint    i;      /* loop variable */
+    int offset, offset2;
+    uint32  x1, x2, x1m, x2m, y1, y2, y1m, y2m; /* new way */
+    int tmp;
+    int rnd1, rnd2;
+    uint32 mask;
+
+    /* initialize offset to adjust pixel counter */
+    /*    the next row; full-pel resolution      */
+    offset = width - B_SIZE; /* offset for prev */
+    offset2 = (pred_width_rnd >> 1) - 8; /* offset for pred_block */
+
+    rnd1 = pred_width_rnd & 1;
+
+    rnd2 = rnd1 + 1;
+    rnd2 |= (rnd2 << 8);
+    rnd2 |= (rnd2 << 16);
+
+    mask = 0x3F;
+    mask |= (mask << 8);
+    mask |= (mask << 16); /* 0x3f3f3f3f */
+
+    tmp = (uint32)prev & 3;
+
+    pred_block -= 4; /* preset */
+
+    if (tmp == 0) /* word-aligned */
+    {
+        for (i = B_SIZE; i > 0; i--)
+        {
+            x1 = *((uint32*)prev); /* load a3 a2 a1 a0 */
+            x2 = *((uint32*)(prev + width)); /* load b3 b2 b1 b0, another line */
+            y1 = *((uint32*)(prev += 4)); /* a7 a6 a5 a4 */
+            y2 = *((uint32*)(prev + width)); /* b7 b6 b5 b4 */
+
+            x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
+            x2m = (x2 >> 2) & mask;
+            x1 = x1 ^(x1m << 2);
+            x2 = x2 ^(x2m << 2);
+            x1m += x2m;
+            x1 += x2;
+
+            /* x2m, x2 free */
+            y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
+            y2m = (y2 >> 2) & mask;
+            y1 = y1 ^(y1m << 2);
+            y2 = y2 ^(y2m << 2);
+            y1m += y2m;
+            y1 += y2;
+
+            /* y2m, y2 free */
+            /* x2m, x2 free */
+            x2 = *((uint32*)(prev += 4)); /* a11 a10 a9 a8 */
+            y2 = *((uint32*)(prev + width)); /* b11 b10 b9 b8 */
+            x2m = (x2 >> 2) & mask;
+            y2m = (y2 >> 2) & mask;
+            x2 = x2 ^(x2m << 2);
+            y2 = y2 ^(y2m << 2);
+            x2m += y2m;
+            x2 += y2;
+            /* y2m, y2 free */
+
+            /* now operate on x1m, x1, y1m, y1, x2m, x2 */
+            /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
+            /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
+            /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
+            /* x1, y1, x2 */
+
+            y2m = x1m >> 8;
+            y2 = x1 >> 8;
+            y2m |= (y1m << 24);  /* a4+b4, a3+b3, a2+b2, a1+b1 */
+            y2 |= (y1 << 24);
+            x1m += y2m;  /* a3+b3+a4+b4, ....., a0+b0+a1+b1 */
+            x1 += y2;
+            x1 += rnd2;
+            x1 &= (mask << 2);
+            x1m += (x1 >> 2);
+            *((uint32*)(pred_block += 4)) = x1m; /* save x1m */
+
+            y2m = y1m >> 8;
+            y2 = y1 >> 8;
+            y2m |= (x2m << 24); /* a8+b8, a7+b7, a6+b6, a5+b5 */
+            y2 |= (x2 << 24);
+            y1m += y2m;  /* a7+b7+a8+b8, ....., a4+b4+a5+b5 */
+            y1 += y2;
+            y1 += rnd2;
+            y1 &= (mask << 2);
+            y1m += (y1 >> 2);
+            *((uint32*)(pred_block += 4)) = y1m; /* save y1m */
+
+            pred_block += offset2;
+            prev += offset;
+        }
+
+        return 1;
+    }
+    else if (tmp == 1)
+    {
+        prev--; /* to word-aligned */
+        for (i = B_SIZE; i > 0; i--)
+        {
+            x1 = *((uint32*)prev); /* load a3 a2 a1 a0 */
+            x2 = *((uint32*)(prev + width)); /* load b3 b2 b1 b0, another line */
+            y1 = *((uint32*)(prev += 4)); /* a7 a6 a5 a4 */
+            y2 = *((uint32*)(prev + width)); /* b7 b6 b5 b4 */
+
+            x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
+            x2m = (x2 >> 2) & mask;
+            x1 = x1 ^(x1m << 2);
+            x2 = x2 ^(x2m << 2);
+            x1m += x2m;
+            x1 += x2;
+
+            /* x2m, x2 free */
+            y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
+            y2m = (y2 >> 2) & mask;
+            y1 = y1 ^(y1m << 2);
+            y2 = y2 ^(y2m << 2);
+            y1m += y2m;
+            y1 += y2;
+
+            /* y2m, y2 free */
+            /* x2m, x2 free */
+            x2 = *((uint32*)(prev += 4)); /* a11 a10 a9 a8 */
+            y2 = *((uint32*)(prev + width)); /* b11 b10 b9 b8 */
+            x2m = (x2 >> 2) & mask;
+            y2m = (y2 >> 2) & mask;
+            x2 = x2 ^(x2m << 2);
+            y2 = y2 ^(y2m << 2);
+            x2m += y2m;
+            x2 += y2;
+            /* y2m, y2 free */
+
+            /* now operate on x1m, x1, y1m, y1, x2m, x2 */
+            /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
+            /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
+            /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
+            /* x1, y1, x2 */
+
+            x1m >>= 8 ;
+            x1 >>= 8;
+            x1m |= (y1m << 24);  /* a4+b4, a3+b3, a2+b2, a1+b1 */
+            x1 |= (y1 << 24);
+            y2m = (y1m << 16);
+            y2 = (y1 << 16);
+            y2m |= (x1m >> 8); /* a5+b5, a4+b4, a3+b3, a2+b2 */
+            y2 |= (x1 >> 8);
+            x1 += rnd2;
+            x1m += y2m;  /* a4+b4+a5+b5, ....., a1+b1+a2+b2 */
+            x1 += y2;
+            x1 &= (mask << 2);
+            x1m += (x1 >> 2);
+            *((uint32*)(pred_block += 4)) = x1m; /* save x1m */
+
+            y1m >>= 8;
+            y1 >>= 8;
+            y1m |= (x2m << 24); /* a8+b8, a7+b7, a6+b6, a5+b5 */
+            y1 |= (x2 << 24);
+            y2m = (x2m << 16);
+            y2 = (x2 << 16);
+            y2m |= (y1m >> 8); /*  a9+b9, a8+b8, a7+b7, a6+b6,*/
+            y2 |= (y1 >> 8);
+            y1 += rnd2;
+            y1m += y2m;  /* a8+b8+a9+b9, ....., a5+b5+a6+b6 */
+            y1 += y2;
+            y1 &= (mask << 2);
+            y1m += (y1 >> 2);
+            *((uint32*)(pred_block += 4)) = y1m; /* save y1m */
+
+            pred_block += offset2;
+            prev += offset;
+        }
+        return 1;
+    }
+    else if (tmp == 2)
+    {
+        prev -= 2; /* to word-aligned */
+        for (i = B_SIZE; i > 0; i--)
+        {
+            x1 = *((uint32*)prev); /* load a3 a2 a1 a0 */
+            x2 = *((uint32*)(prev + width)); /* load b3 b2 b1 b0, another line */
+            y1 = *((uint32*)(prev += 4)); /* a7 a6 a5 a4 */
+            y2 = *((uint32*)(prev + width)); /* b7 b6 b5 b4 */
+
+            x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
+            x2m = (x2 >> 2) & mask;
+            x1 = x1 ^(x1m << 2);
+            x2 = x2 ^(x2m << 2);
+            x1m += x2m;
+            x1 += x2;
+
+            /* x2m, x2 free */
+            y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
+            y2m = (y2 >> 2) & mask;
+            y1 = y1 ^(y1m << 2);
+            y2 = y2 ^(y2m << 2);
+            y1m += y2m;
+            y1 += y2;
+
+            /* y2m, y2 free */
+            /* x2m, x2 free */
+            x2 = *((uint32*)(prev += 4)); /* a11 a10 a9 a8 */
+            y2 = *((uint32*)(prev + width)); /* b11 b10 b9 b8 */
+            x2m = (x2 >> 2) & mask;
+            y2m = (y2 >> 2) & mask;
+            x2 = x2 ^(x2m << 2);
+            y2 = y2 ^(y2m << 2);
+            x2m += y2m;
+            x2 += y2;
+            /* y2m, y2 free */
+
+            /* now operate on x1m, x1, y1m, y1, x2m, x2 */
+            /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
+            /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
+            /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
+            /* x1, y1, x2 */
+
+            x1m >>= 16 ;
+            x1 >>= 16;
+            x1m |= (y1m << 16);  /* a5+b5, a4+b4, a3+b3, a2+b2 */
+            x1 |= (y1 << 16);
+            y2m = (y1m << 8);
+            y2 = (y1 << 8);
+            y2m |= (x1m >> 8); /* a6+b6, a5+b5, a4+b4, a3+b3 */
+            y2 |= (x1 >> 8);
+            x1 += rnd2;
+            x1m += y2m;  /* a5+b5+a6+b6, ....., a2+b2+a3+b3 */
+            x1 += y2;
+            x1 &= (mask << 2);
+            x1m += (x1 >> 2);
+            *((uint32*)(pred_block += 4)) = x1m; /* save x1m */
+
+            y1m >>= 16;
+            y1 >>= 16;
+            y1m |= (x2m << 16); /* a9+b9, a8+b8, a7+b7, a6+b6 */
+            y1 |= (x2 << 16);
+            y2m = (x2m << 8);
+            y2 = (x2 << 8);
+            y2m |= (y1m >> 8); /*  a10+b10, a9+b9, a8+b8, a7+b7,*/
+            y2 |= (y1 >> 8);
+            y1 += rnd2;
+            y1m += y2m;  /* a9+b9+a10+b10, ....., a6+b6+a7+b7 */
+            y1 += y2;
+            y1 &= (mask << 2);
+            y1m += (y1 >> 2);
+            *((uint32*)(pred_block += 4)) = y1m; /* save y1m */
+
+            pred_block += offset2;
+            prev += offset;
+        }
+        return 1;
+    }
+    else /* tmp == 3 */
+    {
+        prev -= 3; /* to word-aligned */
+        for (i = B_SIZE; i > 0; i--)
+        {
+            x1 = *((uint32*)prev); /* load a3 a2 a1 a0 */
+            x2 = *((uint32*)(prev + width)); /* load b3 b2 b1 b0, another line */
+            y1 = *((uint32*)(prev += 4)); /* a7 a6 a5 a4 */
+            y2 = *((uint32*)(prev + width)); /* b7 b6 b5 b4 */
+
+            x1m = (x1 >> 2) & mask; /* zero out last 2 bits */
+            x2m = (x2 >> 2) & mask;
+            x1 = x1 ^(x1m << 2);
+            x2 = x2 ^(x2m << 2);
+            x1m += x2m;
+            x1 += x2;
+
+            /* x2m, x2 free */
+            y1m = (y1 >> 2) & mask; /* zero out last 2 bits */
+            y2m = (y2 >> 2) & mask;
+            y1 = y1 ^(y1m << 2);
+            y2 = y2 ^(y2m << 2);
+            y1m += y2m;
+            y1 += y2;
+
+            /* y2m, y2 free */
+            /* x2m, x2 free */
+            x2 = *((uint32*)(prev += 4)); /* a11 a10 a9 a8 */
+            y2 = *((uint32*)(prev + width)); /* b11 b10 b9 b8 */
+            x2m = (x2 >> 2) & mask;
+            y2m = (y2 >> 2) & mask;
+            x2 = x2 ^(x2m << 2);
+            y2 = y2 ^(y2m << 2);
+            x2m += y2m;
+            x2 += y2;
+            /* y2m, y2 free */
+
+            /* now operate on x1m, x1, y1m, y1, x2m, x2 */
+            /* x1m = a3+b3, a2+b2, a1+b1, a0+b0 */
+            /* y1m = a7+b7, a6+b6, a5+b5, a4+b4 */
+            /* x2m = a11+b11, a10+b10, a9+b9, a8+b8 */
+            /* x1, y1, x2 */
+
+            x1m >>= 24 ;
+            x1 >>= 24;
+            x1m |= (y1m << 8);  /* a6+b6, a5+b5, a4+b4, a3+b3 */
+            x1 |= (y1 << 8);
+
+            x1m += y1m;  /* a6+b6+a7+b7, ....., a3+b3+a4+b4 */
+            x1 += y1;
+            x1 += rnd2;
+            x1 &= (mask << 2);
+            x1m += (x1 >> 2);
+            *((uint32*)(pred_block += 4)) = x1m; /* save x1m */
+
+            y1m >>= 24;
+            y1 >>= 24;
+            y1m |= (x2m << 8); /* a10+b10, a9+b9, a8+b8, a7+b7 */
+            y1 |= (x2 << 8);
+            y1m += x2m;  /* a10+b10+a11+b11, ....., a7+b7+a8+b8 */
+            y1 += x2;
+            y1 += rnd2;
+            y1 &= (mask << 2);
+            y1m += (y1 >> 2);
+            *((uint32*)(pred_block += 4)) = y1m; /* save y1m */
+
+            pred_block += offset2;
+            prev += offset;
+        }
+        return 1;
+    }
+}
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/get_pred_outside.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/get_pred_outside.cpp
new file mode 100644
index 0000000..9cd9022
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/get_pred_outside.cpp
@@ -0,0 +1,514 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    xpos = x half-pixel of (x,y) coordinates within a VOP; motion
+           compensated coordinates; native data type
+    ypos = y half-pixel of (x,y) coordinates within a VOP; motion
+           compensated coordinates; native data type
+    comp = pointer to 8-bit compensated prediction values within a VOP;
+           computed by this module (i/o); full-pel resolution; 8-bit data
+    c_prev = pointer to previous 8-bit prediction values within a VOP;
+         values range from (0-255); full-pel resolution; 8-bit data
+    sh_d = pointer to residual values used to compensate the predicted
+           value; values range from (-512 to 511); full-pel resolution;
+           native data type
+    width = width of the VOP in pixels (x axis); full-pel resolution;
+        native data type
+    height = height of the VOP in pixels (y axis); full-pel resolution;
+         native data type
+    rnd1 = rounding value for case when one dimension uses half-pel
+           resolution; native data type
+    rnd2 = rounding value for case when two dimensions uses half-pel
+           resolution; native data type
+
+ Outputs:
+    returns 1
+
+ Local Stores/Buffers/Pointers Needed:
+    None
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Pointers and Buffers Modified:
+    comp = buffer contains newly computed compensated prediction values
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ Summary:
+
+ This function performs motion compensated prediction for the case where
+ the motion vector points to a block outside the VOP. The function interpolates
+ the pixels that are outside the VOP using the boundary pixels for the block.
+ Once the values are interpolated, the pixel values are computed for a block
+ in the current VOP. The prediction values are generated by averaging pixel
+ values in the previous VOP; the block position in the previous frame is
+ computed from the current block's motion vector. The computed pixel values
+ are calculated by adding the prediction values to the block residual values.
+
+ Details:
+
+ First, this functions determines which VOP boundary(ies) the motion vector
+ is outside, i.e., left, right, top, bottom. xpos is compared to the left and
+ right boundaries; ypos is compared to the top and bottom boundaries. The number
+ of block pixels inside the the boundary in the x and y directions are stored
+ in endx and endy, respectively. If the entire block is inside the x or y
+ boundary, the respectively end is set to 0.
+
+ After the boundaries are tested, any pixels lying outside a boundary are
+ interpolated from the boundary pixels. For example, if the block is outside the
+ bottom boundary, boundary pixels alone the bottom of the VOP as used to
+ interpolated those pixels lying outside the bottom boundary. The interpolation
+ used is a simple column-wise or row-wise copy of the boundary pixels (inside the
+ block) depending on which boundary the block is outside. In our example, each
+ boundary pixel would be copied column-wise to the pixel beneath it. If the
+ block was outside right boundary, the boundary pixels would be copied row-wise
+ to the pixel to the right of it. If the block was outside both an x and y
+ boundary, the boundary pixels would be copied row-wise for the portion of the
+ block outside the x boundary, and column-wise for the portion of the block
+ outside the y boundary. And so on.
+
+ Once the pixel interpolation is complete, the motion compensated output values
+ (comp[]) are calculed from the motion compensated prediction (pred[])values and
+ the residual values (sh_d[]) of the current frame. The prediction values are
+ generated by averaging pixel values in the previous VOP; the block position in
+ the previous frame is computed from the current block's motion vector. The
+ computed pixel values are calculated by adding the prediction values to the
+ block residual values.
+
+*/
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4dec_lib.h"
+#include "motion_comp.h"
+
+#define PAD_CORNER {    temp = *prev; \
+            temp |= (temp<<8);  \
+            temp |= (temp<<16); \
+            *((uint32*)ptr) = temp; \
+            *((uint32*)(ptr+4)) = temp;  \
+            *((uint32*)(ptr+=16)) = temp;  \
+            *((uint32*)(ptr+4)) = temp;  \
+            *((uint32*)(ptr+=16)) = temp;  \
+            *((uint32*)(ptr+4)) = temp;  \
+            *((uint32*)(ptr+=16)) = temp;  \
+            *((uint32*)(ptr+4)) = temp;  \
+            *((uint32*)(ptr+=16)) = temp;  \
+            *((uint32*)(ptr+4)) = temp;  \
+            *((uint32*)(ptr+=16)) = temp;  \
+            *((uint32*)(ptr+4)) = temp;  \
+            *((uint32*)(ptr+=16)) = temp;  \
+            *((uint32*)(ptr+4)) = temp;  \
+            *((uint32*)(ptr+=16)) = temp;  \
+            *((uint32*)(ptr+4)) = temp;  }
+
+#define PAD_ROW  {  temp = *((uint32*)prev); \
+                    temp2 = *((uint32*)(prev+4)); \
+            *((uint32*)ptr) =  temp;\
+            *((uint32*)(ptr+4)) =  temp2; \
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp2;\
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp2;\
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp2;\
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp2;\
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp2;\
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp2;\
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp2;}
+
+#define PAD_EXTRA_4x8           {   temp = *((uint32*)(prev+8)); \
+                *((uint32*)ptr) =  temp; \
+                *((uint32*)(ptr+=16)) = temp; \
+                *((uint32*)(ptr+=16)) = temp; \
+                *((uint32*)(ptr+=16)) = temp; \
+                *((uint32*)(ptr+=16)) = temp; \
+                *((uint32*)(ptr+=16)) = temp; \
+                *((uint32*)(ptr+=16)) = temp; \
+                *((uint32*)(ptr+=16)) = temp; }
+
+#define PAD_COL { temp = *prev; \
+            temp|=(temp<<8);  temp|=(temp<<16); \
+            *((uint32*)ptr) = temp; \
+            *((uint32*)(ptr+4)) = temp; \
+            temp = *(prev+=16); \
+            temp|=(temp<<8);  temp|=(temp<<16); \
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp; \
+            temp = *(prev+=16); \
+            temp|=(temp<<8);  temp|=(temp<<16); \
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp; \
+            temp = *(prev+=16); \
+            temp|=(temp<<8);  temp|=(temp<<16); \
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp; \
+            temp = *(prev+=16); \
+            temp|=(temp<<8);  temp|=(temp<<16); \
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp; \
+            temp = *(prev+=16); \
+            temp|=(temp<<8);  temp|=(temp<<16); \
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp; \
+            temp = *(prev+=16); \
+            temp|=(temp<<8);  temp|=(temp<<16); \
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp; \
+            temp = *(prev+=16); \
+            temp|=(temp<<8);  temp|=(temp<<16); \
+            *((uint32*)(ptr+=16)) = temp; \
+            *((uint32*)(ptr+4)) = temp;}
+
+/* copy 8x8 block */
+#define COPY_BLOCK  {           *((uint32*)ptr) = *((uint32*)prev); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4));  }
+
+#define COPY_12x8       {       *((uint32*)ptr) = *((uint32*)prev); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); \
+            *((uint32*)(ptr+=16)) = *((uint32*)(prev+=width)); \
+            *((uint32*)(ptr+4)) = *((uint32*)(prev+4)); \
+            *((uint32*)(ptr+8)) = *((uint32*)(prev+8)); }
+
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+int GetPredOutside(
+    int xpos,       /* i */
+    int ypos,       /* i */
+    uint8 *c_prev,      /* i */
+    uint8 *pred_block,      /* i */
+    int width,      /* i */
+    int height,     /* i */
+    int rnd1,       /* i */
+    int pred_width
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    uint8   *prev;      /* pointers to adjacent pixels in the    */
+    uint8   pred[256];  /* storage for padded pixel values, 16x16 */
+    uint8   *ptr;
+    int xoffset;
+    uint32 temp, temp2;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* saturate xpos and ypos */
+    if (xpos < -16) xpos = -16;
+    if (xpos > ((width - 1) << 1)) xpos = (width - 1) << 1;
+    if (ypos < -16) ypos = -16;
+    if (ypos > ((height - 1) << 1)) ypos = (height - 1) << 1;
+
+    if (xpos < 0)
+    {
+        if (ypos < 0) /* pad top left of frame */
+        {
+            /* copy the block */
+            ptr = pred + (8 << 4) + 8;
+            prev = c_prev;
+            COPY_BLOCK
+
+            /* pad the corner */
+            ptr = pred;
+            prev = pred + (8 << 4) + 8;
+            PAD_CORNER
+
+            /* pad top */
+            ptr = pred + 8;
+            prev = pred + (8 << 4) + 8;
+            PAD_ROW
+
+            /* pad left */
+            ptr = pred + (8 << 4);
+            prev = pred + (8 << 4) + 8;
+            PAD_COL
+
+
+            ptr = pred + (((ypos >> 1) + 8) << 4) + (xpos >> 1) + 8;
+
+            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);
+
+            return 1;
+        }
+        else if ((ypos >> 1) < (height - B_SIZE)) /* pad left of frame */
+        {
+            /* copy block */
+            ptr = pred + 8;
+            prev = c_prev + (ypos >> 1) * width;
+            COPY_BLOCK
+            /* copy extra line */
+            *((uint32*)(ptr += 16)) = *((uint32*)(prev += width));
+            *((uint32*)(ptr + 4)) = *((uint32*)(prev + 4));
+
+            /* pad left */
+            ptr = pred;
+            prev = pred + 8;
+            PAD_COL
+            /* pad extra line */
+            temp = *(prev += 16);
+            temp |= (temp << 8);
+            temp |= (temp << 16);
+            *((uint32*)(ptr += 16)) = temp;
+            *((uint32*)(ptr + 4)) = temp;
+
+            ptr = pred + 8 + (xpos >> 1);
+
+            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);
+
+            return 1;
+        }
+        else /* pad bottom left of frame */
+        {
+            /* copy the block */
+            ptr = pred + 8; /* point to the center */
+            prev = c_prev + width * (height - 8);
+            COPY_BLOCK
+
+            /* pad the corner */
+            ptr = pred + (8 << 4);
+            prev = ptr - 8;
+            PAD_CORNER
+
+            /* pad bottom */
+            ptr = pred + (8 << 4) + 8;
+            prev = ptr - 16;
+            PAD_ROW
+
+            /* pad left */
+            ptr = pred ;
+            prev = ptr + 8;
+            PAD_COL
+
+            ptr = pred + 8 + (((ypos >> 1) - (height - 8)) << 4) + (xpos >> 1);
+
+            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);
+
+            return 1;
+        }
+    }
+    else if ((xpos >> 1) < (width - B_SIZE))
+    {
+        if (ypos < 0) /* pad top of frame */
+        {
+            xoffset = xpos >> 1;
+            xoffset = xoffset & 0x3; /* word align ptr */
+
+            /* copy block */
+            ptr = pred + (8 << 4);
+            prev = c_prev + (xpos >> 1) - xoffset;
+
+            if (xoffset || (xpos&1)) /* copy extra 4x8 */
+            {
+                COPY_12x8
+            }
+            else
+            {
+                COPY_BLOCK
+            }
+
+            /* pad top */
+            ptr = pred;
+            prev = pred + (8 << 4);
+            PAD_ROW
+            if (xoffset || (xpos&1)) /* pad extra 4x8 */
+            {
+                ptr = pred + 8;
+                PAD_EXTRA_4x8
+            }
+
+            ptr = pred + (((ypos >> 1) + 8) << 4) + xoffset;
+
+            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);
+
+            return 1;
+        }
+        else /* pad bottom of frame */
+        {
+            xoffset = xpos >> 1;
+            xoffset = xoffset & 0x3; /* word align ptr */
+            /* copy block */
+            ptr = pred ;
+            prev = c_prev + width * (height - 8) + (xpos >> 1) - xoffset;
+            if (xoffset  || (xpos&1))
+            {
+                COPY_12x8
+            }
+            else
+            {
+                COPY_BLOCK
+            }
+
+            /* pad bottom */
+            ptr = pred + (8 << 4);
+            prev = ptr - 16;
+            PAD_ROW
+            if (xoffset || (xpos&1))
+            {
+                ptr = pred + (8 << 4) + 8;
+                PAD_EXTRA_4x8
+            }
+
+            ptr = pred + (((ypos >> 1) - (height - 8)) << 4) + xoffset;
+
+            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);
+
+            return 1;
+        }
+    }
+    else
+    {
+        if (ypos < 0) /* pad top right of frame */
+        {
+            /* copy block */
+            ptr = pred + (8 << 4);
+            prev = c_prev + width - 8;
+            COPY_BLOCK
+
+            /* pad top-right */
+            ptr = pred + 8;
+            prev = pred + (8 << 4) + 7;
+            PAD_CORNER
+
+            /* pad top */
+            ptr = pred ;
+            prev = pred + (8 << 4);
+            PAD_ROW;
+
+            /* pad right */
+            ptr = pred + (8 << 4) + 8;
+            prev = ptr - 1;
+            PAD_COL;
+
+            ptr = pred + ((8 + (ypos >> 1)) << 4) + (8 - (width - (xpos >> 1)));
+
+            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);
+
+            return 1;
+        }
+        else if ((ypos >> 1) < (height - B_SIZE)) /* pad right of frame */
+        {
+            /* copy block */
+            ptr = pred;
+            prev = c_prev + (ypos >> 1) * width + width - 8;
+            COPY_BLOCK
+            /* copy extra line */
+            *((uint32*)(ptr += 16)) = *((uint32*)(prev += width));
+            *((uint32*)(ptr + 4)) = *((uint32*)(prev + 4));
+
+            /* pad right */
+            ptr = pred + 8;
+            prev = ptr - 1;
+            PAD_COL;
+            /* pad extra line */
+            temp = *(prev += 16);
+            temp |= (temp << 8);
+            temp |= (temp << 16);
+            *((uint32*)(ptr += 16)) = temp;
+            *((uint32*)(ptr + 4)) = temp;
+
+
+            ptr = pred + 8 - (width - (xpos >> 1));
+
+            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);
+
+            return 1;
+
+        }
+        else /* pad bottom right of frame */
+        {
+            /* copy block */
+            ptr = pred;
+            prev = c_prev + width * (height - 8) + width - 8;
+            COPY_BLOCK
+
+            /* pad bottom-right */
+            ptr = pred + (8 << 4) + 8;
+            prev = ptr - 17;
+            PAD_CORNER
+
+            /* pad right */
+            ptr = pred + 8;
+            prev = ptr - 1;
+            PAD_COL
+
+            /* pad bottom */
+            ptr = pred + (8 << 4);
+            prev = ptr - 16;
+            PAD_ROW
+
+            ptr = pred + 8 - (width - (xpos >> 1)) + ((8 - (height - (ypos >> 1))) << 4);
+
+            GetPredAdvBTable[ypos&1][xpos&1](ptr, pred_block, 16, (pred_width << 1) | rnd1);
+
+            return 1;
+        }
+    }
+}
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/idct.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/idct.cpp
new file mode 100644
index 0000000..2e932a4
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/idct.cpp
@@ -0,0 +1,579 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ MODULE DESCRIPTION
+
+ This file contains the functions that transform an 8r8 image block from
+ dequantized DCT coefficients to spatial domain pirel values by calculating
+ inverse discrete cosine transform (IDCT).
+
+------------------------------------------------------------------------------
+*/
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4dec_lib.h"
+#include "idct.h"
+#include "motion_comp.h"
+#ifndef FAST_IDCT
+
+/*
+------------------------------------------------------------------------------
+ FUNCTION NAME: idct
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS FOR idct
+
+ Inputs:
+    blk = pointer to the buffer containing the dequantized DCT
+          coefficients of type int for an 8r8 image block;
+          values range from (-2048, 2047) which defined as standard.
+
+ Local Stores/Buffers/Pointers Needed:
+    None
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Outputs:
+    None
+
+ Pointers and Buffers Modified:
+    blk points to the found IDCT values for an 8r8 image block.
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION FOR idct
+
+ This function transforms an 8r8 image block from dequantized DCT coefficients
+ (F(u,v)) to spatial domain pirel values (f(r,y)) by performing the two
+ dimensional inverse discrete cosine transform (IDCT).
+
+         _7_ _7_      C(u) C(v)
+    f(r,y) = \   \  F(u,v)---- ----cos[(2r+1)*u*pi/16]cos[(2y+1)*v*pi/16]
+         /__ /__    2    2
+         u=0 v=0
+
+    where   C(i) = 1/sqrt(2)    if i=0
+        C(i) = 1        otherwise
+
+ 2-D IDCT can be separated as horizontal(row-wise) and vertical(column-wise)
+ 1-D IDCTs. Therefore, 2-D IDCT values are found by the following two steps:
+ 1. Find horizontal 1-D IDCT values for each row from 8r8 dequantized DCT
+    coefficients by row IDCT operation.
+
+          _7_        C(u)
+    g(r,v) =  \   F(u,v) ---- cos[(2r+1)*u*pi/16]
+          /__         2
+          u=0
+
+ 2. Find vertical 1-D IDCT values for each column from the results of 1
+    by column IDCT operation.
+
+              _7_        C(v)
+    f(r,y) =  \   g(r,v) ---- cos[(2y+1)*v*pi/16]
+          /__         2
+          v=0
+
+------------------------------------------------------------------------------
+ REQUIREMENTS FOR idct
+
+ None
+
+------------------------------------------------------------------------------
+*/
+/*  REFERENCES FOR idct */
+/* idct.c, inverse fast discrete cosine transform
+ inverse two dimensional DCT, Chen-Wang algorithm
+ (cf. IEEE ASSP-32, pp. 803-816, Aug. 1984)
+ 32-bit integer arithmetic (8 bit coefficients)
+ 11 mults, 29 adds per DCT
+ sE, 18.8.91
+
+ coefficients ertended to 12 bit for IEEE1180-1990
+ compliance                           sE,  2.1.94
+*/
+
+
+/*----------------------------------------------------------------------------
+; Function Code FOR idct
+----------------------------------------------------------------------------*/
+void idct_intra(
+    int *blk, uint8 *comp, int width
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int i;
+    int32   tmpBLK[64];
+    int32   *tmpBLK32 = &tmpBLK[0];
+    int32   r0, r1, r2, r3, r4, r5, r6, r7, r8; /* butterfly nodes */
+    int32   a;
+    int offset = width - 8;
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* two dimensional inverse discrete cosine transform */
+
+
+    /* column (vertical) IDCT */
+    for (i = B_SIZE - 1; i >= 0; i--)
+    {
+        /* initialize butterfly nodes at first stage */
+
+        r1 = blk[B_SIZE * 4 + i] << 11;
+        /* since row IDCT results have net left shift by 3 */
+        /* this left shift by 8 gives net left shift by 11 */
+        /* in order to maintain the same scale as that of  */
+        /* coefficients Wi */
+
+        r2 = blk[B_SIZE * 6 + i];
+        r3 = blk[B_SIZE * 2 + i];
+        r4 = blk[B_SIZE * 1 + i];
+        r5 = blk[B_SIZE * 7 + i];
+        r6 = blk[B_SIZE * 5 + i];
+        r7 = blk[B_SIZE * 3 + i];
+
+        if (!(r1 | r2 | r3 | r4 | r5 | r6 | r7))
+        {
+            /* shortcut */
+            /* execute if values of g(r,1) to g(r,7) in a column*/
+            /* are all zeros */
+
+            /* make output of IDCT >>3 or scaled by 1/8 and */
+            /* with the proper rounding */
+            a = (blk[B_SIZE * 0 + i]) << 3;
+            tmpBLK32[B_SIZE * 0 + i] = a;
+            tmpBLK32[B_SIZE * 1 + i] = a;
+            tmpBLK32[B_SIZE * 2 + i] = a;
+            tmpBLK32[B_SIZE * 3 + i] = a;
+            tmpBLK32[B_SIZE * 4 + i] = a;
+            tmpBLK32[B_SIZE * 5 + i] = a;
+            tmpBLK32[B_SIZE * 6 + i] = a;
+            tmpBLK32[B_SIZE * 7 + i] = a;
+        }
+        else
+        {
+            r0 = (blk[8 * 0 + i] << 11) + 128;
+
+            /* first stage */
+
+            r8 = W7 * (r4 + r5);
+            r4 = (r8 + (W1 - W7) * r4);
+            /* Multiplication with Wi increases the net left */
+            /* shift from 11 to 14,we have to shift back by 3*/
+            r5 = (r8 - (W1 + W7) * r5);
+            r8 = W3 * (r6 + r7);
+            r6 = (r8 - (W3 - W5) * r6);
+            r7 = (r8 - (W3 + W5) * r7);
+
+            /* second stage */
+            r8 = r0 + r1;
+            r0 -= r1;
+
+            r1 = W6 * (r3 + r2);
+            r2 = (r1 - (W2 + W6) * r2);
+            r3 = (r1 + (W2 - W6) * r3);
+
+            r1 = r4 + r6;
+            r4 -= r6;
+            r6 = r5 + r7;
+            r5 -= r7;
+
+            /* third stage */
+            r7 = r8 + r3;
+            r8 -= r3;
+            r3 = r0 + r2;
+            r0 -= r2;
+            r2 = (181 * (r4 + r5) + 128) >> 8;  /* rounding */
+            r4 = (181 * (r4 - r5) + 128) >> 8;
+
+            /* fourth stage */
+            /* net shift of IDCT is >>3 after the following */
+            /* shift operation, it makes output of 2-D IDCT */
+            /* scaled by 1/8, that is scaled twice by       */
+            /* 1/(2*sqrt(2)) for row IDCT and column IDCT.  */
+            /* see detail analysis in design doc.           */
+            tmpBLK32[0 + i] = (r7 + r1) >> 8;
+            tmpBLK32[(1<<3) + i] = (r3 + r2) >> 8;
+            tmpBLK32[(2<<3) + i] = (r0 + r4) >> 8;
+            tmpBLK32[(3<<3) + i] = (r8 + r6) >> 8;
+            tmpBLK32[(4<<3) + i] = (r8 - r6) >> 8;
+            tmpBLK32[(5<<3) + i] = (r0 - r4) >> 8;
+            tmpBLK32[(6<<3) + i] = (r3 - r2) >> 8;
+            tmpBLK32[(7<<3) + i] = (r7 - r1) >> 8;
+        }
+    }
+    /* row (horizontal) IDCT */
+    for (i = 0 ; i < B_SIZE; i++)
+    {
+        /* initialize butterfly nodes at the first stage */
+
+        r1 = ((int32)tmpBLK32[4+(i<<3)]) << 8;
+        /* r1 left shift by 11 is to maintain the same  */
+        /* scale as that of coefficients (W1,...W7) */
+        /* since blk[4] won't multiply with Wi.     */
+        /* see detail diagram in design document.   */
+
+        r2 = tmpBLK32[6+(i<<3)];
+        r3 = tmpBLK32[2+(i<<3)];
+        r4 = tmpBLK32[1+(i<<3)];
+        r5 = tmpBLK32[7+(i<<3)];
+        r6 = tmpBLK32[5+(i<<3)];
+        r7 = tmpBLK32[3+(i<<3)];
+
+        if (!(r1 | r2 | r3 | r4 | r5 | r6 | r7))
+        {
+            /* shortcut */
+            /* execute if values of F(1,v) to F(7,v) in a row*/
+            /* are all zeros */
+
+            /* output of row IDCT scaled by 8 */
+            a = (((int32)tmpBLK32[0+(i<<3)] + 32) >> 6);
+            CLIP_RESULT(a)
+            *comp++ = a;
+            *comp++ = a;
+            *comp++ = a;
+            *comp++ = a;
+            *comp++ = a;
+            *comp++ = a;
+            *comp++ = a;
+            *comp++ = a;
+
+            comp += offset;
+        }
+
+        else
+        {
+            /* for proper rounding in the fourth stage */
+            r0 = (((int32)tmpBLK32[0+(i<<3)]) << 8) + 8192;
+
+            /* first stage */
+
+            r8 = W7 * (r4 + r5) + 4;
+            r4 = (r8 + (W1 - W7) * r4) >> 3;
+            r5 = (r8 - (W1 + W7) * r5) >> 3;
+
+            r8 = W3 * (r6 + r7) + 4;
+            r6 = (r8 - (W3 - W5) * r6) >> 3;
+            r7 = (r8 - (W3 + W5) * r7) >> 3;
+
+            /* second stage */
+            r8 = r0 + r1;
+            r0 -= r1;
+
+            r1 = W6 * (r3 + r2) + 4;
+            r2 = (r1 - (W2 + W6) * r2) >> 3;
+            r3 = (r1 + (W2 - W6) * r3) >> 3;
+
+            r1 = r4 + r6;
+            r4 -= r6;
+            r6 = r5 + r7;
+            r5 -= r7;
+
+            /* third stage */
+            r7 = r8 + r3;
+            r8 -= r3;
+            r3 = r0 + r2;
+            r0 -= r2;
+            r2 = (181 * (r4 + r5) + 128) >> 8;    /* rounding */
+            r4 = (181 * (r4 - r5) + 128) >> 8;
+
+            /* fourth stage */
+            /* net shift of this function is <<3 after the    */
+            /* following shift operation, it makes output of  */
+            /* row IDCT scaled by 8 to retain 3 bits precision*/
+            a = ((r7 + r1) >> 14);
+            CLIP_RESULT(a)
+            *comp++ = a;
+            a = ((r3 + r2) >> 14);
+            CLIP_RESULT(a)
+            *comp++ = a;
+            a = ((r0 + r4) >> 14);
+            CLIP_RESULT(a)
+            *comp++ = a;
+            a = ((r8 + r6) >> 14);
+            CLIP_RESULT(a)
+            *comp++ = a;
+            a = ((r8 - r6) >> 14);
+            CLIP_RESULT(a)
+            *comp++ = a;
+            a = ((r0 - r4) >> 14);
+            CLIP_RESULT(a)
+            *comp++ = a;
+            a = ((r3 - r2) >> 14);
+            CLIP_RESULT(a)
+            *comp++ = a;
+            a = ((r7 - r1) >> 14);
+            CLIP_RESULT(a)
+            *comp++ = a;
+
+            comp += offset;
+        }
+    }
+
+
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+
+void idct(
+    int *blk, uint8 *pred, uint8 *dst, int width)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int i;
+    int32   tmpBLK[64];
+    int32   *tmpBLK32 = &tmpBLK[0];
+    int32   r0, r1, r2, r3, r4, r5, r6, r7, r8; /* butterfly nodes */
+    int32   a;
+    int res;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* two dimensional inverse discrete cosine transform */
+
+
+    /* column (vertical) IDCT */
+    for (i = B_SIZE - 1; i >= 0; i--)
+    {
+        /* initialize butterfly nodes at first stage */
+
+        r1 = blk[B_SIZE * 4 + i] << 11;
+        /* since row IDCT results have net left shift by 3 */
+        /* this left shift by 8 gives net left shift by 11 */
+        /* in order to maintain the same scale as that of  */
+        /* coefficients Wi */
+
+        r2 = blk[B_SIZE * 6 + i];
+        r3 = blk[B_SIZE * 2 + i];
+        r4 = blk[B_SIZE * 1 + i];
+        r5 = blk[B_SIZE * 7 + i];
+        r6 = blk[B_SIZE * 5 + i];
+        r7 = blk[B_SIZE * 3 + i];
+
+        if (!(r1 | r2 | r3 | r4 | r5 | r6 | r7))
+        {
+            /* shortcut */
+            /* execute if values of g(r,1) to g(r,7) in a column*/
+            /* are all zeros */
+
+            /* make output of IDCT >>3 or scaled by 1/8 and */
+            /* with the proper rounding */
+            a = (blk[B_SIZE * 0 + i]) << 3;
+            tmpBLK32[B_SIZE * 0 + i] = a;
+            tmpBLK32[B_SIZE * 1 + i] = a;
+            tmpBLK32[B_SIZE * 2 + i] = a;
+            tmpBLK32[B_SIZE * 3 + i] = a;
+            tmpBLK32[B_SIZE * 4 + i] = a;
+            tmpBLK32[B_SIZE * 5 + i] = a;
+            tmpBLK32[B_SIZE * 6 + i] = a;
+            tmpBLK32[B_SIZE * 7 + i] = a;
+        }
+        else
+        {
+            r0 = (blk[8 * 0 + i] << 11) + 128;
+
+            /* first stage */
+
+            r8 = W7 * (r4 + r5);
+            r4 = (r8 + (W1 - W7) * r4);
+            /* Multiplication with Wi increases the net left */
+            /* shift from 11 to 14,we have to shift back by 3*/
+            r5 = (r8 - (W1 + W7) * r5);
+            r8 = W3 * (r6 + r7);
+            r6 = (r8 - (W3 - W5) * r6);
+            r7 = (r8 - (W3 + W5) * r7);
+
+            /* second stage */
+            r8 = r0 + r1;
+            r0 -= r1;
+
+            r1 = W6 * (r3 + r2);
+            r2 = (r1 - (W2 + W6) * r2);
+            r3 = (r1 + (W2 - W6) * r3);
+
+            r1 = r4 + r6;
+            r4 -= r6;
+            r6 = r5 + r7;
+            r5 -= r7;
+
+            /* third stage */
+            r7 = r8 + r3;
+            r8 -= r3;
+            r3 = r0 + r2;
+            r0 -= r2;
+            r2 = (181 * (r4 + r5) + 128) >> 8;  /* rounding */
+            r4 = (181 * (r4 - r5) + 128) >> 8;
+
+            /* fourth stage */
+            /* net shift of IDCT is >>3 after the following */
+            /* shift operation, it makes output of 2-D IDCT */
+            /* scaled by 1/8, that is scaled twice by       */
+            /* 1/(2*sqrt(2)) for row IDCT and column IDCT.  */
+            /* see detail analysis in design doc.           */
+            tmpBLK32[0 + i] = (r7 + r1) >> 8;
+            tmpBLK32[(1<<3) + i] = (r3 + r2) >> 8;
+            tmpBLK32[(2<<3) + i] = (r0 + r4) >> 8;
+            tmpBLK32[(3<<3) + i] = (r8 + r6) >> 8;
+            tmpBLK32[(4<<3) + i] = (r8 - r6) >> 8;
+            tmpBLK32[(5<<3) + i] = (r0 - r4) >> 8;
+            tmpBLK32[(6<<3) + i] = (r3 - r2) >> 8;
+            tmpBLK32[(7<<3) + i] = (r7 - r1) >> 8;
+        }
+    }
+    /* row (horizontal) IDCT */
+    for (i = B_SIZE - 1; i >= 0; i--)
+    {
+        /* initialize butterfly nodes at the first stage */
+
+        r1 = ((int32)tmpBLK32[4+(i<<3)]) << 8;
+        /* r1 left shift by 11 is to maintain the same  */
+        /* scale as that of coefficients (W1,...W7) */
+        /* since blk[4] won't multiply with Wi.     */
+        /* see detail diagram in design document.   */
+
+        r2 = tmpBLK32[6+(i<<3)];
+        r3 = tmpBLK32[2+(i<<3)];
+        r4 = tmpBLK32[1+(i<<3)];
+        r5 = tmpBLK32[7+(i<<3)];
+        r6 = tmpBLK32[5+(i<<3)];
+        r7 = tmpBLK32[3+(i<<3)];
+
+        if (!(r1 | r2 | r3 | r4 | r5 | r6 | r7))
+        {
+            /* shortcut */
+            /* execute if values of F(1,v) to F(7,v) in a row*/
+            /* are all zeros */
+
+            /* output of row IDCT scaled by 8 */
+            a = (tmpBLK32[0+(i<<3)] + 32) >> 6;
+            blk[0+(i<<3)] = a;
+            blk[1+(i<<3)] = a;
+            blk[2+(i<<3)] = a;
+            blk[3+(i<<3)] = a;
+            blk[4+(i<<3)] = a;
+            blk[5+(i<<3)] = a;
+            blk[6+(i<<3)] = a;
+            blk[7+(i<<3)] = a;
+
+        }
+
+        else
+        {
+            /* for proper rounding in the fourth stage */
+            r0 = (((int32)tmpBLK32[0+(i<<3)]) << 8) + 8192;
+
+            /* first stage */
+
+            r8 = W7 * (r4 + r5) + 4;
+            r4 = (r8 + (W1 - W7) * r4) >> 3;
+            r5 = (r8 - (W1 + W7) * r5) >> 3;
+
+            r8 = W3 * (r6 + r7) + 4;
+            r6 = (r8 - (W3 - W5) * r6) >> 3;
+            r7 = (r8 - (W3 + W5) * r7) >> 3;
+
+            /* second stage */
+            r8 = r0 + r1;
+            r0 -= r1;
+
+            r1 = W6 * (r3 + r2) + 4;
+            r2 = (r1 - (W2 + W6) * r2) >> 3;
+            r3 = (r1 + (W2 - W6) * r3) >> 3;
+
+            r1 = r4 + r6;
+            r4 -= r6;
+            r6 = r5 + r7;
+            r5 -= r7;
+
+            /* third stage */
+            r7 = r8 + r3;
+            r8 -= r3;
+            r3 = r0 + r2;
+            r0 -= r2;
+            r2 = (181 * (r4 + r5) + 128) >> 8;    /* rounding */
+            r4 = (181 * (r4 - r5) + 128) >> 8;
+
+            /* fourth stage */
+            /* net shift of this function is <<3 after the    */
+            /* following shift operation, it makes output of  */
+            /* row IDCT scaled by 8 to retain 3 bits precision*/
+            blk[0+(i<<3)] = (r7 + r1) >> 14;
+            blk[1+(i<<3)] = (r3 + r2) >> 14;
+            blk[2+(i<<3)] = (r0 + r4) >> 14;
+            blk[3+(i<<3)] = (r8 + r6) >> 14;
+            blk[4+(i<<3)] = (r8 - r6) >> 14;
+            blk[5+(i<<3)] = (r0 - r4) >> 14;
+            blk[6+(i<<3)] = (r3 - r2) >> 14;
+            blk[7+(i<<3)] = (r7 - r1) >> 14;
+        }
+        /*  add with prediction ,  08/03/05 */
+        res = (*pred++ + block[0+(i<<3)]);
+        CLIP_RESULT(res);
+        *dst++ = res;
+        res = (*pred++ + block[1+(i<<3)]);
+        CLIP_RESULT(res);
+        *dst++ = res;
+        res = (*pred++ + block[2+(i<<3)]);
+        CLIP_RESULT(res);
+        *dst++ = res;
+        res = (*pred++ + block[3+(i<<3)]);
+        CLIP_RESULT(res);
+        *dst++ = res;
+        res = (*pred++ + block[4+(i<<3)]);
+        CLIP_RESULT(res);
+        *dst++ = res;
+        res = (*pred++ + block[5+(i<<3)]);
+        CLIP_RESULT(res);
+        *dst++ = res;
+        res = (*pred++ + block[6+(i<<3)]);
+        CLIP_RESULT(res);
+        *dst++ = res;
+        res = (*pred++ + block[7+(i<<3)]);
+        CLIP_RESULT(res);
+        *dst++ = res;
+
+        pred += 8;
+        dst += (width - 8);
+    }
+
+
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+
+#endif
+/*----------------------------------------------------------------------------
+; End Function: idct
+----------------------------------------------------------------------------*/
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/idct.h b/media/libstagefright/codecs/m4v_h263/dec/src/idct.h
new file mode 100644
index 0000000..8edb654
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/idct.h
@@ -0,0 +1,118 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#ifndef idct_h
+#define idct_h
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4dec_lib.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here.
+----------------------------------------------------------------------------*/
+#define INTEGER_IDCT
+
+#ifdef FAST_IDCT
+#ifndef INTEGER_IDCT
+#define INTEGER_IDCT
+#endif
+#endif
+
+#ifdef FAST_IDCT
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    void idctrow0(int16 *blk, uint8 *pred, uint8 *dst, int width);
+    void idctrow1(int16 *blk, uint8 *pred, uint8 *dst, int width);
+    void idctrow2(int16 *blk, uint8 *pred, uint8 *dst, int width);
+    void idctrow3(int16 *blk, uint8 *pred, uint8 *dst, int width);
+    void idctrow4(int16 *blk, uint8 *pred, uint8 *dst, int width);
+    void idctcol0(int16 *blk);
+    void idctcol1(int16 *blk);
+    void idctcol2(int16 *blk);
+    void idctcol3(int16 *blk);
+    void idctcol4(int16 *blk);
+
+    void idctrow0_intra(int16 *blk, PIXEL *comp, int width);
+    void idctrow1_intra(int16 *blk, PIXEL *comp, int width);
+    void idctrow2_intra(int16 *blk, PIXEL *comp, int width);
+    void idctrow3_intra(int16 *blk, PIXEL *comp, int width);
+    void idctrow4_intra(int16 *blk, PIXEL *comp, int width);
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+/* this code assumes ">>" to be a two's-complement arithmetic */
+/* right shift: (-2)>>1 == -1 , (-3)>>1 == -2                 */
+
+/* a positive real constant is converted to an integer scaled by 2048 */
+/* or equivalent to left shift by 11 */
+
+#define W1 2841                 /* 2048*sqrt(2)*cos(1*pi/16) */
+#define W2 2676                 /* 2048*sqrt(2)*cos(2*pi/16) */
+#define W3 2408                 /* 2048*sqrt(2)*cos(3*pi/16) */
+#define W5 1609                 /* 2048*sqrt(2)*cos(5*pi/16) */
+#define W6 1108                 /* 2048*sqrt(2)*cos(6*pi/16) */
+#define W7 565                  /* 2048*sqrt(2)*cos(7*pi/16) */
+#define W1mW7 2276
+#define W1pW7 3406
+#define W5mW3 -799
+#define mW3mW5 -4017
+#define mW2mW6 -3784
+#define W2mW6 1568
+
+/* left shift by 11 is to maintain the accuracy of the decimal point */
+/* for the transform coefficients (W1,...W7) */
+
+/*----------------------------------------------------------------------------
+; EXTERNAL VARIABLES REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; SIMPLE TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; ENUMERATED TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; STRUCTURES TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; GLOBAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; END
+----------------------------------------------------------------------------*/
+#endif
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/idct_vca.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/idct_vca.cpp
new file mode 100644
index 0000000..f35ce4f
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/idct_vca.cpp
@@ -0,0 +1,660 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4def.h"
+#include "idct.h"
+#include "motion_comp.h"
+
+#ifdef FAST_IDCT
+
+/****************************************************************
+*       vca_idct.c : created 6/1/99 for several options
+*                     of hard-coded reduced idct function (using nz_coefs)
+******************************************************************/
+
+/*****************************************************/
+//pretested version
+void idctrow0(int16 *, uint8 *, uint8 *, int)
+{
+    return ;
+}
+void idctcol0(int16 *)
+{
+    return ;
+}
+
+void idctrow1(int16 *blk, uint8 *pred, uint8 *dst, int width)
+{
+    /* shortcut */
+    int tmp;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    width -= 4;
+    dst -= width;
+    pred -= 12;
+    blk -= 8;
+
+    while (i--)
+    {
+        tmp = (*(blk += 8) + 32) >> 6;
+        *blk = 0;
+
+        pred_word = *((uint32*)(pred += 12)); /* read 4 bytes from pred */
+        res = tmp + (pred_word & 0xFF);
+        CLIP_RESULT(res);
+        res2 = tmp + ((pred_word >> 8) & 0xFF);
+        CLIP_RESULT(res2);
+        dst_word = (res2 << 8) | res;
+        res = tmp + ((pred_word >> 16) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 16);
+        res = tmp + ((pred_word >> 24) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += width)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred += 4)); /* read 4 bytes from pred */
+        res = tmp + (pred_word & 0xFF);
+        CLIP_RESULT(res);
+        res2 = tmp + ((pred_word >> 8) & 0xFF);
+        CLIP_RESULT(res2);
+        dst_word = (res2 << 8) | res;
+        res = tmp + ((pred_word >> 16) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 16);
+        res = tmp + ((pred_word >> 24) & 0xFF);
+        CLIP_RESULT(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return;
+}
+
+void idctcol1(int16 *blk)
+{ /* shortcut */
+    blk[0] = blk[8] = blk[16] = blk[24] = blk[32] = blk[40] = blk[48] = blk[56] =
+                                              blk[0] << 3;
+    return;
+}
+
+void idctrow2(int16 *blk, uint8 *pred, uint8 *dst, int width)
+{
+    int32 x0, x1, x2, x4, x5;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    width -= 4;
+    dst -= width;
+    pred -= 12;
+    blk -= 8;
+
+    while (i--)
+    {
+        /* shortcut */
+        x4 = blk[9];
+        blk[9] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;  /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x5 = (W7 * x4 + 4) >> 3;
+        x4 = (W1 * x4 + 4) >> 3;
+
+        /* third stage */
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x1 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        pred_word = *((uint32*)(pred += 12)); /* read 4 bytes from pred */
+        res = (x0 + x4) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 + x2) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 + x5) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += width)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred += 4)); /* read 4 bytes from pred */
+        res = (x0 - x5) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x0 - x1) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x0 - x2) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x4) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+void idctcol2(int16 *blk)
+{
+    int32 x0, x1, x3, x5, x7;//, x8;
+
+    x1 = blk[8];
+    x0 = ((int32)blk[0] << 11) + 128;
+    /* both upper and lower*/
+
+    x7 = W7 * x1;
+    x1 = W1 * x1;
+
+    x3 = x7;
+    x5 = (181 * (x1 - x7) + 128) >> 8;
+    x7 = (181 * (x1 + x7) + 128) >> 8;
+
+    blk[0] = (x0 + x1) >> 8;
+    blk[8] = (x0 + x7) >> 8;
+    blk[16] = (x0 + x5) >> 8;
+    blk[24] = (x0 + x3) >> 8;
+    blk[56] = (x0 - x1) >> 8;
+    blk[48] = (x0 - x7) >> 8;
+    blk[40] = (x0 - x5) >> 8;
+    blk[32] = (x0 - x3) >> 8;
+
+    return ;
+}
+
+void idctrow3(int16 *blk, uint8 *pred, uint8 *dst, int width)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    width -= 4;
+    dst -= width;
+    pred -= 12;
+    blk -= 8;
+
+    while (i--)
+    {
+        x2 = blk[10];
+        blk[10] = 0;
+        x1 = blk[9];
+        blk[9] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;   /* for proper rounding in the fourth stage */
+        /* both upper and lower*/
+        /* both x2orx6 and x0orx4 */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x3 = x7;
+        x5 = (181 * (x1 - x7) + 128) >> 8;
+        x7 = (181 * (x1 + x7) + 128) >> 8;
+
+        pred_word = *((uint32*)(pred += 12)); /* read 4 bytes from pred */
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x4 + x7) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x6 + x5) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x2 + x3) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += width)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred += 4)); /* read 4 bytes from pred */
+        res = (x2 - x3) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x6 - x5) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x4 - x7) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += 4)) = dst_word; /* save 4 bytes to dst */
+    }
+
+    return ;
+}
+
+void idctcol3(int16 *blk)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+
+    x2 = blk[16];
+    x1 = blk[8];
+    x0 = ((int32)blk[0] << 11) + 128;
+
+    x4 = x0;
+    x6 = W6 * x2;
+    x2 = W2 * x2;
+    x8 = x0 - x2;
+    x0 += x2;
+    x2 = x8;
+    x8 = x4 - x6;
+    x4 += x6;
+    x6 = x8;
+
+    x7 = W7 * x1;
+    x1 = W1 * x1;
+    x3 = x7;
+    x5 = (181 * (x1 - x7) + 128) >> 8;
+    x7 = (181 * (x1 + x7) + 128) >> 8;
+
+    blk[0] = (x0 + x1) >> 8;
+    blk[8] = (x4 + x7) >> 8;
+    blk[16] = (x6 + x5) >> 8;
+    blk[24] = (x2 + x3) >> 8;
+    blk[56] = (x0 - x1) >> 8;
+    blk[48] = (x4 - x7) >> 8;
+    blk[40] = (x6 - x5) >> 8;
+    blk[32] = (x2 - x3) >> 8;
+
+    return;
+}
+
+
+void idctrow4(int16 *blk, uint8 *pred, uint8 *dst, int width)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    int i = 8;
+    uint32 pred_word, dst_word;
+    int res, res2;
+
+    /* preset the offset, such that we can take advantage pre-offset addressing mode   */
+    width -= 4;
+    dst -= width;
+    pred -= 12;
+    blk -= 8;
+
+    while (i--)
+    {
+        x2 = blk[10];
+        blk[10] = 0;
+        x1 = blk[9];
+        blk[9] = 0;
+        x3 = blk[11];
+        blk[11] = 0;
+        x0 = ((*(blk += 8)) << 8) + 8192;
+        *blk = 0;    /* for proper rounding in the fourth stage */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x5 = (W3 * x3 + 4) >> 3;
+        x3 = (- W5 * x3 + 4) >> 3;
+        x8 = x1 - x5;
+        x1 += x5;
+        x5 = x8;
+        x8 = x7 - x3;
+        x3 += x7;
+        x7 = (181 * (x5 + x8) + 128) >> 8;
+        x5 = (181 * (x5 - x8) + 128) >> 8;
+
+        pred_word = *((uint32*)(pred += 12)); /* read 4 bytes from pred */
+        res = (x0 + x1) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x4 + x7) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x6 + x5) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x2 + x3) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += width)) = dst_word; /* save 4 bytes to dst */
+
+        pred_word = *((uint32*)(pred += 4)); /* read 4 bytes from pred */
+        res = (x2 - x3) >> 14;
+        ADD_AND_CLIP1(res);
+        res2 = (x6 - x5) >> 14;
+        ADD_AND_CLIP2(res2);
+        dst_word = (res2 << 8) | res;
+        res = (x4 - x7) >> 14;
+        ADD_AND_CLIP3(res);
+        dst_word |= (res << 16);
+        res = (x0 - x1) >> 14;
+        ADD_AND_CLIP4(res);
+        dst_word |= (res << 24);
+        *((uint32*)(dst += 4)) = dst_word; /* save 4 bytes to dst */
+    }
+    return ;
+}
+
+void idctcol4(int16 *blk)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8;
+    x2 = blk[16];
+    x1 = blk[8];
+    x3 = blk[24];
+    x0 = ((int32)blk[0] << 11) + 128;
+
+    x4 = x0;
+    x6 = W6 * x2;
+    x2 = W2 * x2;
+    x8 = x0 - x2;
+    x0 += x2;
+    x2 = x8;
+    x8 = x4 - x6;
+    x4 += x6;
+    x6 = x8;
+
+    x7 = W7 * x1;
+    x1 = W1 * x1;
+    x5 = W3 * x3;
+    x3 = -W5 * x3;
+    x8 = x1 - x5;
+    x1 += x5;
+    x5 = x8;
+    x8 = x7 - x3;
+    x3 += x7;
+    x7 = (181 * (x5 + x8) + 128) >> 8;
+    x5 = (181 * (x5 - x8) + 128) >> 8;
+
+
+    blk[0] = (x0 + x1) >> 8;
+    blk[8] = (x4 + x7) >> 8;
+    blk[16] = (x6 + x5) >> 8;
+    blk[24] = (x2 + x3) >> 8;
+    blk[56] = (x0 - x1) >> 8;
+    blk[48] = (x4 - x7) >> 8;
+    blk[40] = (x6 - x5) >> 8;
+    blk[32] = (x2 - x3) >> 8;
+
+    return ;
+}
+
+void idctrow0_intra(int16 *, PIXEL *, int)
+{
+    return ;
+}
+
+void idctrow1_intra(int16 *blk, PIXEL *comp, int width)
+{
+    /* shortcut */
+    int32 tmp;
+    int i = 8;
+    int offset = width;
+    uint32 word;
+
+    comp -= offset;
+    while (i--)
+    {
+        tmp = ((blk[0] + 32) >> 6);
+        blk[0] = 0;
+        CLIP_RESULT(tmp)
+
+        word = (tmp << 8) | tmp;
+        word = (word << 16) | word;
+
+        *((uint32*)(comp += offset)) = word;
+        *((uint32*)(comp + 4)) = word;
+
+
+
+
+        blk += B_SIZE;
+    }
+    return;
+}
+
+void idctrow2_intra(int16 *blk, PIXEL *comp, int width)
+{
+    int32 x0, x1, x2, x4, x5, temp;
+    int i = 8;
+    int offset = width;
+    int32 word;
+
+    comp -= offset;
+    while (i--)
+    {
+        /* shortcut */
+        x4 = blk[1];
+        blk[1] = 0;
+        x0 = ((int32)blk[0] << 8) + 8192;
+        blk[0] = 0;   /* for proper rounding in the fourth stage */
+
+        /* first stage */
+        x5 = (W7 * x4 + 4) >> 3;
+        x4 = (W1 * x4 + 4) >> 3;
+
+        /* third stage */
+        x2 = (181 * (x4 + x5) + 128) >> 8;
+        x1 = (181 * (x4 - x5) + 128) >> 8;
+
+        /* fourth stage */
+        word = ((x0 + x4) >> 14);
+        CLIP_RESULT(word)
+
+        temp = ((x0 + x2) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 8);
+        temp = ((x0 + x1) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 16);
+        temp = ((x0 + x5) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 24);
+        *((int32*)(comp += offset)) = word;
+
+        word = ((x0 - x5) >> 14);
+        CLIP_RESULT(word)
+        temp = ((x0 - x1) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 8);
+        temp = ((x0 - x2) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 16);
+        temp = ((x0 - x4) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 24);
+        *((int32*)(comp + 4)) = word;
+
+        blk += B_SIZE;
+    }
+    return ;
+}
+
+void idctrow3_intra(int16 *blk, PIXEL *comp, int width)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8, temp;
+    int i = 8;
+    int offset = width;
+    int32 word;
+
+    comp -= offset;
+
+    while (i--)
+    {
+        x2 = blk[2];
+        blk[2] = 0;
+        x1 = blk[1];
+        blk[1] = 0;
+        x0 = ((int32)blk[0] << 8) + 8192;
+        blk[0] = 0;/* for proper rounding in the fourth stage */
+        /* both upper and lower*/
+        /* both x2orx6 and x0orx4 */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x3 = x7;
+        x5 = (181 * (x1 - x7) + 128) >> 8;
+        x7 = (181 * (x1 + x7) + 128) >> 8;
+
+        word = ((x0 + x1) >> 14);
+        CLIP_RESULT(word)
+        temp = ((x4 + x7) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 8);
+
+
+        temp = ((x6 + x5) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 16);
+
+        temp = ((x2 + x3) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 24);
+        *((int32*)(comp += offset)) = word;
+
+        word = ((x2 - x3) >> 14);
+        CLIP_RESULT(word)
+
+        temp = ((x6 - x5) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 8);
+
+        temp = ((x4 - x7) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 16);
+
+        temp = ((x0 - x1) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 24);
+        *((int32*)(comp + 4)) = word;
+
+        blk += B_SIZE;
+    }
+    return ;
+}
+
+void idctrow4_intra(int16 *blk, PIXEL *comp, int width)
+{
+    int32 x0, x1, x2, x3, x4, x5, x6, x7, x8, temp;
+    int i = 8;
+    int offset = width;
+    int32 word;
+
+    comp -= offset;
+
+    while (i--)
+    {
+        x2 = blk[2];
+        blk[2] = 0;
+        x1 = blk[1];
+        blk[1] = 0;
+        x3 = blk[3];
+        blk[3] = 0;
+        x0 = ((int32)blk[0] << 8) + 8192;
+        blk[0] = 0;/* for proper rounding in the fourth stage */
+
+        x4 = x0;
+        x6 = (W6 * x2 + 4) >> 3;
+        x2 = (W2 * x2 + 4) >> 3;
+        x8 = x0 - x2;
+        x0 += x2;
+        x2 = x8;
+        x8 = x4 - x6;
+        x4 += x6;
+        x6 = x8;
+
+        x7 = (W7 * x1 + 4) >> 3;
+        x1 = (W1 * x1 + 4) >> 3;
+        x5 = (W3 * x3 + 4) >> 3;
+        x3 = (- W5 * x3 + 4) >> 3;
+        x8 = x1 - x5;
+        x1 += x5;
+        x5 = x8;
+        x8 = x7 - x3;
+        x3 += x7;
+        x7 = (181 * (x5 + x8) + 128) >> 8;
+        x5 = (181 * (x5 - x8) + 128) >> 8;
+
+        word = ((x0 + x1) >> 14);
+        CLIP_RESULT(word)
+
+        temp = ((x4 + x7) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 8);
+
+
+        temp = ((x6 + x5) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 16);
+
+        temp = ((x2 + x3) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 24);
+        *((int32*)(comp += offset)) = word;
+
+        word = ((x2 - x3) >> 14);
+        CLIP_RESULT(word)
+
+        temp = ((x6 - x5) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 8);
+
+        temp = ((x4 - x7) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 16);
+
+        temp = ((x0 - x1) >> 14);
+        CLIP_RESULT(temp)
+        word = word | (temp << 24);
+        *((int32*)(comp + 4)) = word;
+
+        blk += B_SIZE;
+    }
+
+    return ;
+}
+
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/max_level.h b/media/libstagefright/codecs/m4v_h263/dec/src/max_level.h
new file mode 100644
index 0000000..2d59c73
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/max_level.h
@@ -0,0 +1,149 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+*     -------------------------------------------------------------------   *
+*                    MPEG-4 Simple Profile Video Decoder                    *
+*     -------------------------------------------------------------------   *
+*
+* This software module was originally developed by
+*
+*   Michael Wollborn (TUH / ACTS-MoMuSyS)
+*
+* in the course of development of the MPEG-4 Video (ISO/IEC 14496-2) standard.
+* This software module is an implementation of a part of one or more MPEG-4
+* Video (ISO/IEC 14496-2) tools as specified by the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* ISO/IEC gives users of the MPEG-4 Video (ISO/IEC 14496-2) standard free
+* license to this software module or modifications thereof for use in hardware
+* or software products claiming conformance to the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* Those intending to use this software module in hardware or software products
+* are advised that its use may infringe existing patents. The original
+* developer of this software module and his/her company, the subsequent
+* editors and their companies, and ISO/IEC have no liability for use of this
+* software module or modifications thereof in an implementation. Copyright is
+* not released for non MPEG-4 Video (ISO/IEC 14496-2) Standard conforming
+* products.
+*
+* ACTS-MoMuSys partners retain full right to use the code for his/her own
+* purpose, assign or donate the code to a third party and to inhibit third
+* parties from using the code for non MPEG-4 Video (ISO/IEC 14496-2) Standard
+* conforming products. This copyright notice must be included in all copies or
+* derivative works.
+*
+* Copyright (c) 1997
+*
+*****************************************************************************
+
+This is a header file for "vlc_decode.c".  The table data actually resides
+in "vlc_tab.c".
+
+
+------------------------------------------------------------------------------
+*/
+
+/*----------------------------------------------------------------------------
+; CONTINUE ONLY IF NOT ALREADY DEFINED
+----------------------------------------------------------------------------*/
+
+#ifndef max_level_H
+#define max_level_H
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4def.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL VARIABLES REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    extern const int intra_max_level[2][NCOEFF_BLOCK];
+
+    extern const int inter_max_level[2][NCOEFF_BLOCK];
+
+    extern const int intra_max_run0[28];
+
+
+    extern const int intra_max_run1[9];
+
+    extern const int inter_max_run0[13];
+
+
+    extern const int inter_max_run1[4];
+
+
+    /*----------------------------------------------------------------------------
+    ; SIMPLE TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; ENUMERATED TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; STRUCTURES TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+
+    /*----------------------------------------------------------------------------
+    ; GLOBAL FUNCTION DEFINITIONS
+    ; Function Prototype declaration
+    ----------------------------------------------------------------------------*/
+
+
+    /*----------------------------------------------------------------------------
+    ; END
+    ----------------------------------------------------------------------------*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/mb_motion_comp.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/mb_motion_comp.cpp
new file mode 100644
index 0000000..fbc7be1
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/mb_motion_comp.cpp
@@ -0,0 +1,623 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    video = pointer to structure of type VideoDecData
+
+ Local Stores/Buffers/Pointers Needed:
+    roundtab16 = rounding table
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Outputs:
+    None
+
+ Pointers and Buffers Modified:
+    video->currVop->yChan contents are the newly calculated luminance
+      data
+    video->currVop->uChan contents are the newly calculated chrominance
+      b data
+    video->currVop->vChan contents are the newly calculated chrominance
+      r data
+    video->pstprcTypCur contents are the updated semaphore propagation
+      values
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ This function performs high level motion compensation on the luminance and
+ chrominance data. It sets up all the parameters required by the functions
+ that perform luminance and chrominance prediction and it initializes the
+ pointer to the post processing semaphores of a given block. It also checks
+ the motion compensation mode in order to determine which luminance or
+ chrominance prediction functions to call and determines how the post
+ processing semaphores are updated.
+
+*/
+
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4dec_lib.h"
+#include "motion_comp.h"
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+/* 09/29/2000 bring this from mp4def.h */
+// const static int roundtab4[] = {0,1,1,1};
+// const static int roundtab8[] = {0,0,1,1,1,1,1,2};
+/*** 10/30 for TPS */
+// const static int roundtab12[] = {0,0,0,1,1,1,1,1,1,1,2,2};
+/* 10/30 for TPS ***/
+const static int roundtab16[] = {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
+
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+
+/** modified 3 August 2005 to do prediction and put the results in
+video->mblock->pred_block, no adding with residue */
+
+void  MBMotionComp(
+    VideoDecData *video,
+    int CBP
+)
+{
+
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    /* Previous Video Object Plane */
+    Vop *prev = video->prevVop;
+
+    /* Current Macroblock (MB) in the VOP */
+    int mbnum = video->mbnum;
+
+    /* Number of MB per data row */
+    int MB_in_width = video->nMBPerRow;
+    int ypos, xpos;
+    PIXEL *c_comp, *c_prev;
+    PIXEL *cu_comp, *cu_prev;
+    PIXEL *cv_comp, *cv_prev;
+    int height, width, pred_width;
+    int imv, mvwidth;
+    int32 offset;
+    uint8 mode;
+    uint8 *pred_block, *pred;
+
+    /* Motion vector (dx,dy) in half-pel resolution */
+    int dx, dy;
+
+    MOT px[4], py[4];
+    int xpred, ypred;
+    int xsum;
+    int round1;
+#ifdef PV_POSTPROC_ON // 2/14/2001      
+    /* Total number of pixels in the VOL */
+    int32 size = (int32) video->nTotalMB << 8;
+    uint8 *pp_dec_y, *pp_dec_u;
+    int ll[4];
+    int tmp = 0;
+    uint8 msk_deblock = 0;
+#endif
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* Set rounding type */
+    /* change from array to single 09/29/2000 */
+    round1 = (int)(1 - video->currVop->roundingType);
+
+    /* width of luminance data in pixels (y axis) */
+    width = video->width;
+
+    /* heigth of luminance data in pixels (x axis) */
+    height = video->height;
+
+    /* number of blocks per row */
+    mvwidth = MB_in_width << 1;
+
+    /* starting y position in current MB; origin of MB */
+    ypos = video->mbnum_row << 4 ;
+    /* starting x position in current MB; origin of MB */
+    xpos = video->mbnum_col << 4 ;
+
+    /* offset to (x,y) position in current luminance MB */
+    /* in pixel resolution                              */
+    /* ypos*width -> row, +x -> column */
+    offset = (int32)ypos * width + xpos;
+
+    /* get mode for current MB */
+    mode = video->headerInfo.Mode[mbnum];
+
+    /* block index */
+    /* imv = (xpos/8) + ((ypos/8) * mvwidth) */
+    imv = (offset >> 6) - (xpos >> 6) + (xpos >> 3);
+    if (mode & INTER_1VMASK)
+    {
+        dx = px[0] = px[1] = px[2] = px[3] = video->motX[imv];
+        dy = py[0] = py[1] = py[2] = py[3] = video->motY[imv];
+        if ((dx & 3) == 0)
+        {
+            dx = dx >> 1;
+        }
+        else
+        {
+            /* x component of MV is or'ed for rounding (?) */
+            dx = (dx >> 1) | 1;
+        }
+
+        /* y component of motion vector; divide by 2 for to */
+        /* convert to full-pel resolution.                  */
+        if ((dy & 3) == 0)
+        {
+            dy = dy >> 1;
+        }
+        else
+        {
+            /* y component of MV is or'ed for rounding (?) */
+            dy = (dy >> 1) | 1;
+        }
+    }
+    else
+    {
+        px[0] = video->motX[imv];
+        px[1] = video->motX[imv+1];
+        px[2] = video->motX[imv+mvwidth];
+        px[3] = video->motX[imv+mvwidth+1];
+        xsum = px[0] + px[1] + px[2] + px[3];
+        dx = PV_SIGN(xsum) * (roundtab16[(PV_ABS(xsum)) & 0xF] +
+                              (((PV_ABS(xsum)) >> 4) << 1));
+        py[0] = video->motY[imv];
+        py[1] = video->motY[imv+1];
+        py[2] = video->motY[imv+mvwidth];
+        py[3] = video->motY[imv+mvwidth+1];
+        xsum = py[0] + py[1] + py[2] + py[3];
+        dy = PV_SIGN(xsum) * (roundtab16[(PV_ABS(xsum)) & 0xF] +
+                              (((PV_ABS(xsum)) >> 4) << 1));
+    }
+
+    /* Pointer to previous luminance frame */
+    c_prev  = prev->yChan;
+
+    pred_block = video->mblock->pred_block;
+
+    /* some blocks have no residue or INTER4V */
+    /*if (mode == MODE_INTER4V)   05/08/15 */
+    /* Motion Compensation for an 8x8 block within a MB */
+    /* (4 MV per MB) */
+
+
+
+    /* Call function that performs luminance prediction */
+    /*      luminance_pred_mode_inter4v(xpos, ypos, px, py, c_prev,
+                    video->mblock->pred_block, width, height,
+                    round1, mvwidth, &xsum, &ysum);*/
+    c_comp = video->currVop->yChan + offset;
+
+
+    xpred = (int)((xpos << 1) + px[0]);
+    ypred = (int)((ypos << 1) + py[0]);
+
+    if ((CBP >> 5)&1)
+    {
+        pred = pred_block;
+        pred_width = 16;
+    }
+    else
+    {
+        pred = c_comp;
+        pred_width = width;
+    }
+
+    /* check whether the MV points outside the frame */
+    if (xpred >= 0 && xpred <= ((width << 1) - (2*B_SIZE)) &&
+            ypred >= 0 && ypred <= ((height << 1) - (2*B_SIZE)))
+    {   /*****************************/
+        /* (x,y) is inside the frame */
+        /*****************************/
+        ;
+        GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*width),
+                                           pred, width, (pred_width << 1) | round1);
+    }
+    else
+    {   /******************************/
+        /* (x,y) is outside the frame */
+        /******************************/
+        GetPredOutside(xpred, ypred, c_prev,
+                       pred, width, height, round1, pred_width);
+    }
+
+
+    /* Compute prediction values over current luminance MB */
+    /* (blocks 1); add motion vector prior to input;       */
+    /* add 8 to x_pos to advance to next block         */
+    xpred = (int)(((xpos + B_SIZE) << 1) + px[1]);
+    ypred = (int)((ypos << 1) + py[1]);
+
+    if ((CBP >> 4)&1)
+    {
+        pred = pred_block + 8;
+        pred_width = 16;
+    }
+    else
+    {
+        pred = c_comp + 8;
+        pred_width = width;
+    }
+
+    /* check whether the MV points outside the frame */
+    if (xpred >= 0 && xpred <= ((width << 1) - (2*B_SIZE)) &&
+            ypred >= 0 && ypred <= ((height << 1) - (2*B_SIZE)))
+    {   /*****************************/
+        /* (x,y) is inside the frame */
+        /*****************************/
+        GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*width),
+                                           pred, width, (pred_width << 1) | round1);
+    }
+    else
+    {   /******************************/
+        /* (x,y) is outside the frame */
+        /******************************/
+        GetPredOutside(xpred, ypred, c_prev,
+                       pred, width, height, round1, pred_width);
+    }
+
+
+
+    /* Compute prediction values over current luminance MB */
+    /* (blocks 2); add motion vector prior to input        */
+    /* add 8 to y_pos to advance to block on next row      */
+    xpred = (int)((xpos << 1) + px[2]);
+    ypred = (int)(((ypos + B_SIZE) << 1) + py[2]);
+
+    if ((CBP >> 3)&1)
+    {
+        pred = pred_block + 128;
+        pred_width = 16;
+    }
+    else
+    {
+        pred = c_comp + (width << 3);
+        pred_width = width;
+    }
+
+    /* check whether the MV points outside the frame */
+    if (xpred >= 0 && xpred <= ((width << 1) - (2*B_SIZE)) &&
+            ypred >= 0 && ypred <= ((height << 1) - (2*B_SIZE)))
+    {   /*****************************/
+        /* (x,y) is inside the frame */
+        /*****************************/
+        GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*width),
+                                           pred, width, (pred_width << 1) | round1);
+    }
+    else
+    {   /******************************/
+        /* (x,y) is outside the frame */
+        /******************************/
+        GetPredOutside(xpred, ypred, c_prev,
+                       pred, width, height, round1, pred_width);
+    }
+
+
+
+    /* Compute prediction values over current luminance MB */
+    /* (blocks 3); add motion vector prior to input;       */
+    /* add 8 to x_pos and y_pos to advance to next block   */
+    /* on next row                         */
+    xpred = (int)(((xpos + B_SIZE) << 1) + px[3]);
+    ypred = (int)(((ypos + B_SIZE) << 1) + py[3]);
+
+    if ((CBP >> 2)&1)
+    {
+        pred = pred_block + 136;
+        pred_width = 16;
+    }
+    else
+    {
+        pred = c_comp + (width << 3) + 8;
+        pred_width = width;
+    }
+
+    /* check whether the MV points outside the frame */
+    if (xpred >= 0 && xpred <= ((width << 1) - (2*B_SIZE)) &&
+            ypred >= 0 && ypred <= ((height << 1) - (2*B_SIZE)))
+    {   /*****************************/
+        /* (x,y) is inside the frame */
+        /*****************************/
+        GetPredAdvBTable[ypred&1][xpred&1](c_prev + (xpred >> 1) + ((ypred >> 1)*width),
+                                           pred, width, (pred_width << 1) | round1);
+    }
+    else
+    {   /******************************/
+        /* (x,y) is outside the frame */
+        /******************************/
+        GetPredOutside(xpred, ypred, c_prev,
+                       pred, width, height, round1, pred_width);
+    }
+    /* Call function to set de-blocking and de-ringing */
+    /*   semaphores for luminance                      */
+
+#ifdef PV_POSTPROC_ON
+    if (video->postFilterType != PV_NO_POST_PROC)
+    {
+        if (mode&INTER_1VMASK)
+        {
+            pp_dec_y = video->pstprcTypCur + imv;
+            ll[0] = 1;
+            ll[1] = mvwidth - 1;
+            ll[2] = 1;
+            ll[3] = -mvwidth - 1;
+            msk_deblock = pp_semaphore_luma(xpred, ypred, pp_dec_y,
+                                            video->pstprcTypPrv, ll, &tmp, px[0], py[0], mvwidth,
+                                            width, height);
+
+            pp_dec_u = video->pstprcTypCur + (size >> 6) +
+                       ((imv + (xpos >> 3)) >> 2);
+
+            pp_semaphore_chroma_inter(xpred, ypred, pp_dec_u,
+                                      video->pstprcTypPrv, dx, dy, mvwidth, height, size,
+                                      tmp, msk_deblock);
+        }
+        else
+        {
+            /* Post-processing mode (MBM_INTER8) */
+            /* deblocking and deringing) */
+            pp_dec_y = video->pstprcTypCur + imv;
+            *pp_dec_y = 4;
+            *(pp_dec_y + 1) = 4;
+            *(pp_dec_y + mvwidth) = 4;
+            *(pp_dec_y + mvwidth + 1) = 4;
+            pp_dec_u = video->pstprcTypCur + (size >> 6) +
+                       ((imv + (xpos >> 3)) >> 2);
+            *pp_dec_u = 4;
+            pp_dec_u[size>>8] = 4;
+        }
+    }
+#endif
+
+
+    /* xpred and ypred calculation for Chrominance is */
+    /* in full-pel resolution.                        */
+
+    /* Chrominance */
+    /* width of chrominance data in pixels (y axis) */
+    width >>= 1;
+
+    /* heigth of chrominance data in pixels (x axis) */
+    height >>= 1;
+
+    /* Pointer to previous chrominance b frame */
+    cu_prev = prev->uChan;
+
+    /* Pointer to previous chrominance r frame */
+    cv_prev = prev->vChan;
+
+    /* x position in prediction data offset by motion vector */
+    /* xpred calculation for Chrominance is in full-pel      */
+    /* resolution.                                           */
+    xpred = xpos + dx;
+
+    /* y position in prediction data offset by motion vector */
+    /* ypred calculation for Chrominance is in full-pel      */
+    /* resolution.                                           */
+    ypred = ypos + dy;
+
+    cu_comp = video->currVop->uChan + (offset >> 2) + (xpos >> 2);
+    cv_comp = video->currVop->vChan + (offset >> 2) + (xpos >> 2);
+
+    /* Call function that performs chrominance prediction */
+    /*      chrominance_pred(xpred, ypred, cu_prev, cv_prev,
+            pred_block, width_uv, height_uv,
+            round1);*/
+    if (xpred >= 0 && xpred <= ((width << 1) - (2*B_SIZE)) && ypred >= 0 &&
+            ypred <= ((height << 1) - (2*B_SIZE)))
+    {
+        /*****************************/
+        /* (x,y) is inside the frame */
+        /*****************************/
+        if ((CBP >> 1)&1)
+        {
+            pred = pred_block + 256;
+            pred_width = 16;
+        }
+        else
+        {
+            pred = cu_comp;
+            pred_width = width;
+        }
+
+        /* Compute prediction for Chrominance b (block[4]) */
+        GetPredAdvBTable[ypred&1][xpred&1](cu_prev + (xpred >> 1) + ((ypred >> 1)*width),
+                                           pred, width, (pred_width << 1) | round1);
+
+        if (CBP&1)
+        {
+            pred = pred_block + 264;
+            pred_width = 16;
+        }
+        else
+        {
+            pred = cv_comp;
+            pred_width = width;
+        }
+        /* Compute prediction for Chrominance r (block[5]) */
+        GetPredAdvBTable[ypred&1][xpred&1](cv_prev + (xpred >> 1) + ((ypred >> 1)*width),
+                                           pred, width, (pred_width << 1) | round1);
+
+        return ;
+    }
+    else
+    {
+        /******************************/
+        /* (x,y) is outside the frame */
+        /******************************/
+        if ((CBP >> 1)&1)
+        {
+            pred = pred_block + 256;
+            pred_width = 16;
+        }
+        else
+        {
+            pred = cu_comp;
+            pred_width = width;
+        }
+
+        /* Compute prediction for Chrominance b (block[4]) */
+        GetPredOutside(xpred, ypred,    cu_prev,
+                       pred, width, height, round1, pred_width);
+
+        if (CBP&1)
+        {
+            pred = pred_block + 264;
+            pred_width = 16;
+        }
+        else
+        {
+            pred = cv_comp;
+            pred_width = width;
+        }
+
+        /* Compute prediction for Chrominance r (block[5]) */
+        GetPredOutside(xpred, ypred,    cv_prev,
+                       pred, width, height, round1, pred_width);
+
+        return ;
+    }
+
+}
+
+/*** special function for skipped macroblock,  Aug 15, 2005 */
+void  SkippedMBMotionComp(
+    VideoDecData *video
+)
+{
+    Vop *prev = video->prevVop;
+    Vop *comp;
+    int ypos, xpos;
+    PIXEL *c_comp, *c_prev;
+    PIXEL *cu_comp, *cu_prev;
+    PIXEL *cv_comp, *cv_prev;
+    int width, width_uv;
+    int32 offset;
+#ifdef PV_POSTPROC_ON // 2/14/2001      
+    int imv;
+    int32 size = (int32) video->nTotalMB << 8;
+    uint8 *pp_dec_y, *pp_dec_u;
+    uint8 *pp_prev1;
+    int mvwidth = video->nMBPerRow << 1;
+#endif
+
+    width = video->width;
+    width_uv  = width >> 1;
+    ypos = video->mbnum_row << 4 ;
+    xpos = video->mbnum_col << 4 ;
+    offset = (int32)ypos * width + xpos;
+
+
+    /* zero motion compensation for previous frame */
+    /*mby*width + mbx;*/
+    c_prev  = prev->yChan + offset;
+    /*by*width_uv + bx;*/
+    cu_prev = prev->uChan + (offset >> 2) + (xpos >> 2);
+    /*by*width_uv + bx;*/
+    cv_prev = prev->vChan + (offset >> 2) + (xpos >> 2);
+
+    comp = video->currVop;
+
+    c_comp  = comp->yChan + offset;
+    cu_comp = comp->uChan + (offset >> 2) + (xpos >> 2);
+    cv_comp = comp->vChan + (offset >> 2) + (xpos >> 2);
+
+
+    /* Copy previous reconstructed frame into the current frame */
+    PutSKIPPED_MB(c_comp,  c_prev, width);
+    PutSKIPPED_B(cu_comp, cu_prev, width_uv);
+    PutSKIPPED_B(cv_comp, cv_prev, width_uv);
+
+    /*  10/24/2000 post_processing semaphore generation */
+#ifdef PV_POSTPROC_ON // 2/14/2001
+    if (video->postFilterType != PV_NO_POST_PROC)
+    {
+        imv = (offset >> 6) - (xpos >> 6) + (xpos >> 3);
+        /* Post-processing mode (copy previous MB) */
+        pp_prev1 = video->pstprcTypPrv + imv;
+        pp_dec_y = video->pstprcTypCur + imv;
+        *pp_dec_y = *pp_prev1;
+        *(pp_dec_y + 1) = *(pp_prev1 + 1);
+        *(pp_dec_y + mvwidth) = *(pp_prev1 + mvwidth);
+        *(pp_dec_y + mvwidth + 1) = *(pp_prev1 + mvwidth + 1);
+
+        /* chrominance */
+        /*4*MB_in_width*MB_in_height*/
+        pp_prev1 = video->pstprcTypPrv + (size >> 6) +
+                   ((imv + (xpos >> 3)) >> 2);
+        pp_dec_u = video->pstprcTypCur + (size >> 6) +
+                   ((imv + (xpos >> 3)) >> 2);
+        *pp_dec_u = *pp_prev1;
+        pp_dec_u[size>>8] = pp_prev1[size>>8];
+    }
+#endif
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+
+    return;
+}
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/mb_utils.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/mb_utils.cpp
new file mode 100644
index 0000000..25a31b7
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/mb_utils.cpp
@@ -0,0 +1,133 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h"
+
+/* ====================================================================== /
+    Function : PutSKIPPED_MB()
+    Date     : 04/03/2000
+/ ====================================================================== */
+
+void PutSKIPPED_MB(uint8 *comp, uint8 *prev, int width)
+{
+    int32 *temp0, *temp1;
+    int  row;
+    row = MB_SIZE;
+
+
+    while (row)
+    {
+        temp0 = (int32 *)prev;
+        temp1 = (int32 *)comp;
+
+        temp1[0] = temp0[0];
+        temp1[1] = temp0[1];
+        temp1[2] = temp0[2];
+        temp1[3] = temp0[3];
+
+        comp += width;
+        prev += width;
+
+        temp0 = (int32 *)prev;
+        temp1 = (int32 *)comp;
+
+        temp1[0] = temp0[0];
+        temp1[1] = temp0[1];
+        temp1[2] = temp0[2];
+        temp1[3] = temp0[3];
+
+        comp += width;
+        prev += width;
+
+        temp0 = (int32 *)prev;
+        temp1 = (int32 *)comp;
+        temp1[0] = temp0[0];
+        temp1[1] = temp0[1];
+        temp1[2] = temp0[2];
+        temp1[3] = temp0[3];
+
+
+        comp += width;
+        prev += width;
+
+        temp0 = (int32 *)prev;
+        temp1 = (int32 *)comp;
+        temp1[0] = temp0[0];
+        temp1[1] = temp0[1];
+        temp1[2] = temp0[2];
+        temp1[3] = temp0[3];
+
+        comp += width;
+        prev += width;
+        row -= 4;
+    }
+}
+
+
+/* ====================================================================== /
+    Function : PutSKIPPED_B()
+    Date     : 04/03/2000
+/ ====================================================================== */
+
+void PutSKIPPED_B(uint8 *comp, uint8 *prev, int width)
+{
+    int32 *temp0, *temp1;
+    int  row;
+
+    row = B_SIZE;
+    while (row)
+    {
+        temp0 = (int32 *)prev;
+        temp1 = (int32 *)comp;
+
+        temp1[0] = temp0[0];
+        temp1[1] = temp0[1];
+
+        comp += width;
+        prev += width;
+
+        temp0 = (int32 *)prev;
+        temp1 = (int32 *)comp;
+
+        temp1[0] = temp0[0];
+        temp1[1] = temp0[1];
+
+        comp += width;
+        prev += width;
+
+        temp0 = (int32 *)prev;
+        temp1 = (int32 *)comp;
+
+        temp1[0] = temp0[0];
+        temp1[1] = temp0[1];
+
+        comp += width;
+        prev += width;
+
+        temp0 = (int32 *)prev;
+        temp1 = (int32 *)comp;
+
+        temp1[0] = temp0[0];
+        temp1[1] = temp0[1];
+
+        comp += width;
+        prev += width;
+        row -= 4;
+    }
+}
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/mbtype_mode.h b/media/libstagefright/codecs/m4v_h263/dec/src/mbtype_mode.h
new file mode 100644
index 0000000..c45bb5f
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/mbtype_mode.h
@@ -0,0 +1,37 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+const static int MBtype_mode[] =
+{
+    MODE_INTER,
+    MODE_INTER_Q,
+    MODE_INTER4V,
+    MODE_INTRA,
+    MODE_INTRA_Q,
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    MODE_INTER4V_Q,
+#endif
+    MODE_SKIPPED
+};
+#ifdef PV_ANNEX_IJKT_SUPPORT
+const static int16 DQ_tab_Annex_T_10[32] = {0, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3};
+const static int16 DQ_tab_Annex_T_11[32] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 2, 1, -5};
+const static int16 MQ_chroma_QP_table[32] = {0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 13, 13, 13,
+        14, 14, 14, 14, 14, 15, 15, 15, 15, 15
+                                            };
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/motion_comp.h b/media/libstagefright/codecs/m4v_h263/dec/src/motion_comp.h
new file mode 100644
index 0000000..0c12f20
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/motion_comp.h
@@ -0,0 +1,108 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#ifndef motion_comp_h
+#define motion_comp_h
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4dec_lib.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here.
+----------------------------------------------------------------------------*/
+/* CBP Mask defines used in chrominance prediction */
+#define CBP_MASK_CHROMA_BLK4    0x2
+#define CBP_MASK_CHROMA_BLK5    0x1
+
+/* CBP Mask defines used in luminance prediction (MODE_INTER4V) */
+#define CBP_MASK_BLK0_MODE_INTER4V  0x20
+#define CBP_MASK_BLK1_MODE_INTER4V  0x10
+#define CBP_MASK_BLK2_MODE_INTER4V  0x08
+#define CBP_MASK_BLK3_MODE_INTER4V  0x04
+
+/* CBP Mask defines used in luminance prediction (MODE_INTER or MODE_INTER_Q) */
+#define CBP_MASK_MB_MODE_INTER  0x3c
+
+/*----------------------------------------------------------------------------
+; EXTERNAL VARIABLES REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define CLIP_RESULT(x)      if(x & -256){x = 0xFF & (~(x>>31));}
+#define ADD_AND_CLIP1(x)    x += (pred_word&0xFF); CLIP_RESULT(x);
+#define ADD_AND_CLIP2(x)    x += ((pred_word>>8)&0xFF); CLIP_RESULT(x);
+#define ADD_AND_CLIP3(x)    x += ((pred_word>>16)&0xFF); CLIP_RESULT(x);
+#define ADD_AND_CLIP4(x)    x += ((pred_word>>24)&0xFF); CLIP_RESULT(x);
+
+#define ADD_AND_CLIP(x,y)    {  x9 = ~(x>>8); \
+                            if(x9!=-1){ \
+                                x9 = ((uint32)x9)>>24; \
+                                y = x9|(y<<8); \
+                            } \
+                            else \
+                            {    \
+                                y =  x|(y<<8); \
+                            } \
+                            }
+
+
+    static int (*const GetPredAdvBTable[2][2])(uint8*, uint8*, int, int) =
+    {
+        {&GetPredAdvancedBy0x0, &GetPredAdvancedBy0x1},
+        {&GetPredAdvancedBy1x0, &GetPredAdvancedBy1x1}
+    };
+
+    /*----------------------------------------------------------------------------
+    ; SIMPLE TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; ENUMERATED TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; STRUCTURES TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; GLOBAL FUNCTION DEFINITIONS
+    ; Function Prototype declaration
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; END
+    ----------------------------------------------------------------------------*/
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/mp4dec_lib.h b/media/libstagefright/codecs/m4v_h263/dec/src/mp4dec_lib.h
new file mode 100644
index 0000000..9cd4edc
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/mp4dec_lib.h
@@ -0,0 +1,334 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#ifndef _MP4DECLIB_H_
+#define _MP4DECLIB_H_
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4def.h" /* typedef */
+#include "mp4lib_int.h" /* main video structure */
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL VARIABLES REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; SIMPLE TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; ENUMERATED TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; STRUCTURES TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; GLOBAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+    /* defined in pvdec_api.c, these function are not supposed to be    */
+    /* exposed to programmers outside PacketVideo.  08/15/2000.    */
+    uint VideoDecoderErrorDetected(VideoDecData *video);
+
+#ifdef ENABLE_LOG
+    void m4vdec_dprintf(char *format, ...);
+#define mp4dec_log(message) m4vdec_dprintf(message)
+#else
+#define mp4dec_log(message)
+#endif
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in frame_buffer.c */
+    PV_STATUS FillFrameBufferNew(BitstreamDecVideo *stream);
+    PV_STATUS FillFrameBuffer(BitstreamDecVideo *stream, int short_header);
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in dc_ac_pred.c */
+    int cal_dc_scaler(int QP, int type);
+    PV_STATUS PV_DecodePredictedIntraDC(int compnum, BitstreamDecVideo *stream,
+                                        int16 *IntraDC_delta);
+
+    void    doDCACPrediction(VideoDecData *video, int comp, int16 *q_block,
+                             int *direction);
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    void    doDCACPrediction_I(VideoDecData *video, int comp, int16 *q_block);
+#endif
+    /*--------------------------------------------------------------------------*/
+    /* defined in block_idct.c */
+    void MBlockIDCTAdd(VideoDecData *video, int nz_coefs[]);
+
+    void BlockIDCT(uint8 *dst, uint8 *pred, int16 *blk, int width, int nzcoefs,
+                   uint8 *bitmapcol, uint8 bitmaprow);
+
+    void MBlockIDCT(VideoDecData *video);
+    void BlockIDCT_intra(MacroBlock *mblock, PIXEL *c_comp, int comp, int width_offset);
+    /*--------------------------------------------------------------------------*/
+    /* defined in combined_decode.c */
+    PV_STATUS DecodeFrameCombinedMode(VideoDecData *video);
+    PV_STATUS GetMBheader(VideoDecData *video, int16 *QP);
+    PV_STATUS GetMBData(VideoDecData *video);
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in datapart_decode.c */
+    PV_STATUS DecodeFrameDataPartMode(VideoDecData *video);
+    PV_STATUS GetMBheaderDataPart_DQUANT_DC(VideoDecData *video, int16 *QP);
+    PV_STATUS GetMBheaderDataPart_P(VideoDecData *video);
+    PV_STATUS DecodeDataPart_I_VideoPacket(VideoDecData *video, int slice_counter);
+    PV_STATUS DecodeDataPart_P_VideoPacket(VideoDecData *video, int slice_counter);
+    PV_STATUS GetMBData_DataPart(VideoDecData *video);
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in packet_util.c */
+    PV_STATUS PV_ReadVideoPacketHeader(VideoDecData *video, int *next_MB);
+    PV_STATUS RecoverPacketError(BitstreamDecVideo *stream, int marker_length, int32 *nextVop);
+    PV_STATUS RecoverGOBError(BitstreamDecVideo *stream, int marker_length, int32 *vopPos);
+    PV_STATUS PV_GobHeader(VideoDecData *video);
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    PV_STATUS PV_H263SliceHeader(VideoDecData *videoInt, int *next_MB);
+#endif
+    /*--------------------------------------------------------------------------*/
+    /* defined in motion_comp.c */
+    void MBMotionComp(VideoDecData *video, int CBP);
+    void  SkippedMBMotionComp(VideoDecData *video);
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in chrominance_pred.c */
+    void chrominance_pred(
+        int xpred,          /* i */
+        int ypred,          /* i */
+        uint8 *cu_prev,     /* i */
+        uint8 *cv_prev,     /* i */
+        uint8 *pred_block,  /* i */
+        int width_uv,       /* i */
+        int height_uv,      /* i */
+        int round1
+    );
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in luminance_pred_mode_inter.c */
+    void luminance_pred_mode_inter(
+        int xpred,          /* i */
+        int ypred,          /* i */
+        uint8 *c_prev,      /* i */
+        uint8 *pred_block,  /* i */
+        int width,          /* i */
+        int height,         /* i */
+        int round1
+    );
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in luminance_pred_mode_inter4v.c */
+    void luminance_pred_mode_inter4v(
+        int xpos,           /* i */
+        int ypos,           /* i */
+        MOT *px,            /* i */
+        MOT *py,            /* i */
+        uint8 *c_prev,      /* i */
+        uint8 *pred_block,  /* i */
+        int width,          /* i */
+        int height,         /* i */
+        int round1,         /* i */
+        int mvwidth,            /* i */
+        int *xsum_ptr,          /* i/o */
+        int *ysum_ptr           /* i/o */
+    );
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in pp_semaphore_chroma_inter.c */
+#ifdef PV_POSTPROC_ON
+    void pp_semaphore_chroma_inter(
+        int xpred,      /* i */
+        int ypred,      /* i */
+        uint8   *pp_dec_u,  /* i/o */
+        uint8   *pstprcTypPrv,  /* i */
+        int dx,     /* i */
+        int dy,     /* i */
+        int mvwidth,    /* i */
+        int height,     /* i */
+        int32   size,       /* i */
+        int mv_loc,     /* i */
+        uint8   msk_deblock /* i */
+    );
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in pp_semaphore_luma.c */
+    uint8 pp_semaphore_luma(
+        int xpred,      /* i */
+        int ypred,      /* i */
+        uint8   *pp_dec_y,  /* i/o */
+        uint8   *pstprcTypPrv,  /* i */
+        int *ll,        /* i */
+        int *mv_loc,    /* i/o */
+        int dx,     /* i */
+        int dy,     /* i */
+        int mvwidth,    /* i */
+        int width,      /* i */
+        int height      /* i */
+    );
+#endif
+    /*--------------------------------------------------------------------------*/
+    /* defined in get_pred_adv_mb_add.c */
+    int GetPredAdvancedMB(
+        int xpos,
+        int ypos,
+        uint8 *c_prev,
+        uint8 *pred_block,
+        int width,
+        int rnd1
+    );
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in get_pred_adv_b_add.c */
+    int GetPredAdvancedBy0x0(
+        uint8 *c_prev,      /* i */
+        uint8 *pred_block,      /* i */
+        int width,      /* i */
+        int pred_width_rnd /* i */
+    );
+
+    int GetPredAdvancedBy0x1(
+        uint8 *c_prev,      /* i */
+        uint8 *pred_block,      /* i */
+        int width,      /* i */
+        int pred_width_rnd /* i */
+    );
+
+    int GetPredAdvancedBy1x0(
+        uint8 *c_prev,      /* i */
+        uint8 *pred_block,      /* i */
+        int width,      /* i */
+        int pred_width_rnd /* i */
+    );
+
+    int GetPredAdvancedBy1x1(
+        uint8 *c_prev,      /* i */
+        uint8 *pred_block,      /* i */
+        int width,      /* i */
+        int pred_width_rnd /* i */
+    );
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in get_pred_outside.c */
+    int GetPredOutside(
+        int xpos,
+        int ypos,
+        uint8 *c_prev,
+        uint8 *pred_block,
+        int width,
+        int height,
+        int rnd1,
+        int pred_width
+    );
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in find_pmvsErrRes.c */
+    void mv_prediction(VideoDecData *video, int block, MOT *mvx, MOT *mvy);
+
+    /*--------------------------------------------------------------------------*/
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in mb_utils.c */
+    void Copy_MB_into_Vop(uint8 *comp, int yChan[][NCOEFF_BLOCK], int width);
+    void Copy_B_into_Vop(uint8 *comp, int cChan[], int width);
+    void PutSKIPPED_MB(uint8 *comp, uint8 *c_prev, int width);
+    void PutSKIPPED_B(uint8 *comp, uint8 *c_prev, int width);
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in vop.c */
+    PV_STATUS DecodeGOVHeader(BitstreamDecVideo *stream, uint32 *time_base);
+    PV_STATUS DecodeVOLHeader(VideoDecData *video, int layer);
+    PV_STATUS DecodeVOPHeader(VideoDecData *video, Vop *currVop, Bool use_ext_tiemstamp);
+    PV_STATUS DecodeShortHeader(VideoDecData *video, Vop *currVop);
+    PV_STATUS PV_DecodeVop(VideoDecData *video);
+    uint32 CalcVopDisplayTime(Vol *currVol, Vop *currVop, int shortVideoHeader);
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in post_proc.c */
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    void H263_Deblock(uint8 *rec,   int width, int height, int16 *QP_store, uint8 *mode, int chr, int T);
+#endif
+    int  PostProcSemaphore(int16 *q_block);
+    void PostFilter(VideoDecData *video, int filer_type, uint8 *output);
+    void FindMaxMin(uint8 *ptr, int *min, int *max, int incr);
+    void DeringAdaptiveSmoothMMX(uint8 *img, int incr, int thres, int mxdf);
+    void AdaptiveSmooth_NoMMX(uint8 *Rec_Y, int v0, int h0, int v_blk, int h_blk,
+                              int thr, int width, int max_diff);
+    void Deringing_Luma(uint8 *Rec_Y, int width, int height, int16 *QP_store,
+                        int Combined, uint8 *pp_mod);
+    void Deringing_Chroma(uint8 *Rec_C, int width, int height, int16 *QP_store,
+                          int Combined, uint8 *pp_mod);
+    void CombinedHorzVertFilter(uint8 *rec, int width, int height, int16 *QP_store,
+                                int chr, uint8 *pp_mod);
+    void CombinedHorzVertFilter_NoSoftDeblocking(uint8 *rec, int width, int height, int16 *QP_store,
+            int chr, uint8 *pp_mod);
+    void CombinedHorzVertRingFilter(uint8 *rec, int width, int height,
+                                    int16 *QP_store, int chr, uint8 *pp_mod);
+
+    /*--------------------------------------------------------------------------*/
+    /* defined in conceal.c */
+    void ConcealTexture_I(VideoDecData *video, int32 startFirstPartition, int mb_start, int mb_stop,
+                          int slice_counter);
+    void ConcealTexture_P(VideoDecData *video, int mb_start, int mb_stop,
+                          int slice_counter);
+    void ConcealPacket(VideoDecData *video, int mb_start, int mb_stop,
+                       int slice_counter);
+    void CopyVopMB(Vop *curr, uint8 *prev, int mbnum, int width, int height);
+
+    /* define in vlc_dequant.c ,  09/18/2000*/
+#ifdef PV_SUPPORT_MAIN_PROFILE
+    int VlcDequantMpegIntraBlock(void *video, int comp, int switched,
+                                 uint8 *bitmapcol, uint8 *bitmaprow);
+    int VlcDequantMpegInterBlock(void *video, int comp,
+                                 uint8 *bitmapcol, uint8 *bitmaprow);
+#endif
+    int VlcDequantH263IntraBlock(VideoDecData *video, int comp, int switched,
+                                 uint8 *bitmapcol, uint8 *bitmaprow);
+    int VlcDequantH263IntraBlock_SH(VideoDecData *video, int comp,
+                                    uint8 *bitmapcol, uint8 *bitmaprow);
+    int VlcDequantH263InterBlock(VideoDecData *video, int comp,
+                                 uint8 *bitmapcol, uint8 *bitmaprow);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*----------------------------------------------------------------------------
+; END
+----------------------------------------------------------------------------*/
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/mp4def.h b/media/libstagefright/codecs/m4v_h263/dec/src/mp4def.h
new file mode 100644
index 0000000..3388d89
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/mp4def.h
@@ -0,0 +1,167 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#ifndef _PVDECDEF_H_
+#define _PVDECDEF_H_
+
+#include "mp4dec_api.h"
+
+typedef enum
+{
+    PV_SUCCESS,
+    PV_FAIL,
+    PV_MB_STUFFING,         /* hit Macroblock_Stuffing */
+    PV_END_OF_VOP,          /* hit End_of_Video_Object_Plane */
+    PV_END_OF_MB            /* hit End_of_Macroblock */
+#ifdef PV_TOLERATE_VOL_ERRORS
+    , PV_BAD_VOLHEADER
+#endif
+} PV_STATUS;
+
+typedef uint8 PIXEL;
+typedef int16 MOT;   /*  : "int" type runs faster on RISC machine */
+
+#define TRUE    1
+#define FALSE   0
+
+#define PV_ABS(x)       (((x)<0)? -(x) : (x))
+#define PV_SIGN(x)      (((x)<0)? -1 : 1)
+#define PV_SIGN0(a)     (((a)<0)? -1 : (((a)>0) ? 1 : 0))
+#define PV_MAX(a,b)     ((a)>(b)? (a):(b))
+#define PV_MIN(a,b)     ((a)<(b)? (a):(b))
+#define PV_MEDIAN(A,B,C) ((A) > (B) ? ((A) < (C) ? (A) : (B) > (C) ? (B) : (C)): (B) < (C) ? (B) : (C) > (A) ? (C) : (A))
+/* You don't want to use ((x>UB)?UB:(x<LB)?LB:x) for the clipping */
+/*    because it will use one extra comparison if the compiler is */
+/*    not well-optimized.    04/19/2000.                        */
+#define CLIP_THE_RANGE(x,LB,UB) if (x<LB) x = LB; else if (x>UB) x = UB
+
+#define MODE_INTRA      0x08 //01000
+#define MODE_INTRA_Q    0x09 //01001
+#define MODE_SKIPPED    0x10 //10000
+#define MODE_INTER4V    0x14 //10100
+#define MODE_INTER      0x16 //10110
+#define MODE_INTER_Q    0x17 //10111
+#define MODE_INTER4V_Q  0x15 //10101
+#define INTER_1VMASK    0x2
+#define Q_MASK          0x1
+#define INTRA_MASK      0x8
+#define INTER_MASK      0x4
+
+
+#define I_VOP       0
+#define P_VOP       1
+#define B_VOP       2
+
+#define LUMINANCE_DC_TYPE   1
+#define CHROMINANCE_DC_TYPE 2
+
+#define START_CODE_LENGTH       32
+
+/* 11/30/98 */
+#define NoMarkerFound -1
+#define FoundRM     1   /* Resync Marker */
+#define FoundVSC    2   /* VOP_START_CODE. */
+#define FoundGSC    3   /* GROUP_START_CODE */
+#define FoundEOB    4   /* EOB_CODE */
+
+/* PacketVideo "absolution timestamp" object.   06/13/2000 */
+#define PVTS_START_CODE         0x01C4
+#define PVTS_START_CODE_LENGTH  32
+
+/* session layer and vop layer start codes */
+
+#define VISUAL_OBJECT_SEQUENCE_START_CODE   0x01B0
+#define VISUAL_OBJECT_SEQUENCE_END_CODE     0x01B1
+
+#define VISUAL_OBJECT_START_CODE   0x01B5
+#define VO_START_CODE           0x8
+#define VO_HEADER_LENGTH        32      /* lengtho of VO header: VO_START_CODE +  VO_ID */
+
+#define SOL_START_CODE          0x01BE
+#define SOL_START_CODE_LENGTH   32
+
+#define VOL_START_CODE 0x12
+#define VOL_START_CODE_LENGTH 28
+
+#define VOP_START_CODE 0x1B6
+#define VOP_START_CODE_LENGTH   32
+
+#define GROUP_START_CODE    0x01B3
+#define GROUP_START_CODE_LENGTH  32
+
+#define VOP_ID_CODE_LENGTH      5
+#define VOP_TEMP_REF_CODE_LENGTH    16
+
+#define USER_DATA_START_CODE        0x01B2
+#define USER_DATA_START_CODE_LENGTH 32
+
+#define START_CODE_PREFIX       0x01
+#define START_CODE_PREFIX_LENGTH    24
+
+#define SHORT_VIDEO_START_MARKER         0x20
+#define SHORT_VIDEO_START_MARKER_LENGTH  22
+#define SHORT_VIDEO_END_MARKER            0x3F
+#define GOB_RESYNC_MARKER         0x01
+#define GOB_RESYNC_MARKER_LENGTH  17
+
+/* motion and resync markers used in error resilient mode  */
+
+#define DC_MARKER                      438273
+#define DC_MARKER_LENGTH                19
+
+#define MOTION_MARKER_COMB             126977
+#define MOTION_MARKER_COMB_LENGTH       17
+
+#define MOTION_MARKER_SEP              81921
+#define MOTION_MARKER_SEP_LENGTH        17
+
+#define RESYNC_MARKER           1
+#define RESYNC_MARKER_LENGTH    17
+
+#define SPRITE_NOT_USED     0
+#define STATIC_SPRITE       1
+#define ONLINE_SPRITE       2
+#define GMC_SPRITE      3
+
+/* macroblock and block size */
+#define MB_SIZE 16
+#define NCOEFF_MB (MB_SIZE*MB_SIZE)
+#define B_SIZE 8
+#define NCOEFF_BLOCK (B_SIZE*B_SIZE)
+#define NCOEFF_Y NCOEFF_MB
+#define NCOEFF_U NCOEFF_BLOCK
+#define NCOEFF_V NCOEFF_BLOCK
+#define BLK_PER_MB      4   /* Number of blocks per MB */
+
+/* VLC decoding related definitions */
+#define VLC_ERROR   (-1)
+#define VLC_ESCAPE  7167
+
+
+/* macro utility */
+#define  ZERO_OUT_64BYTES(x)    { *((uint32*)x) = *(((uint32*)(x))+1) =  \
+        *(((uint32*)(x))+2) = *(((uint32*)(x))+3) =  \
+        *(((uint32*)(x))+4) = *(((uint32*)(x))+5) =  \
+        *(((uint32*)(x))+6) = *(((uint32*)(x))+7) =  \
+        *(((uint32*)(x))+8) = *(((uint32*)(x))+9) =  \
+        *(((uint32*)(x))+10) = *(((uint32*)(x))+11) =  \
+        *(((uint32*)(x))+12) = *(((uint32*)(x))+13) =  \
+        *(((uint32*)(x))+14) = *(((uint32*)(x))+15) =  0; }
+
+
+
+#endif /* _PVDECDEF_H_ */
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/mp4lib_int.h b/media/libstagefright/codecs/m4v_h263/dec/src/mp4lib_int.h
new file mode 100644
index 0000000..d6754a7
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/mp4lib_int.h
@@ -0,0 +1,296 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#ifndef _MP4LIB_INT_H_
+#define _MP4LIB_INT_H_
+
+#include "mp4def.h"
+#include "mp4dec_api.h" // extra structure
+
+#undef ENABLE_LOG
+#define BITRATE_AVERAGE_WINDOW 4
+#define FRAMERATE_SCALE ((BITRATE_AVERAGE_WINDOW-1)*10000L)
+#define FAST_IDCT            /* , for fast Variable complexity IDCT */
+//#define PV_DEC_EXTERNAL_IDCT  /*  for separate IDCT (i.e. no direct access to output frame) */
+#define PV_ANNEX_IJKT_SUPPORT
+#define mid_gray 1024
+
+typedef struct tagBitstream
+{
+    /* function that reteive data from outside the library.   04/11/2000 */
+    /*    In frame-based decoding mode, this shall be NULL.   08/29/2000 */
+    uint32 curr_word;
+    uint32 next_word;
+    uint8 *bitstreamBuffer; /* pointer to buffer memory */
+    int32  read_point;          /* starting point in the buffer to be read to cache */
+    int  incnt;             /* bit left in cached */
+    int  incnt_next;
+    uint32 bitcnt;          /* total bit read so-far (from inbfr)*/
+    int32  data_end_pos;        /*should be added ,  06/07/2000 */
+    int searched_frame_boundary;
+} BitstreamDecVideo, *LPBitstreamDecVideo;
+
+/* complexity estimation parameters */
+typedef struct tagComplexity_Est
+{
+    uint8   text_1;             /* texture_complexity_estimation_set_1  */
+    uint8   text_2;             /* texture_complexity_estimation_set_2  */
+    uint8   mc;                 /* motion_compensation_complexity       */
+} Complexity_Est;
+
+
+typedef struct tagVop
+{
+    PIXEL   *yChan;             /* The Y component */
+    PIXEL   *uChan;             /* The U component */
+    PIXEL   *vChan;             /* The V component */
+
+    uint32  timeStamp;          /* Vop TimeStamp in msec */
+
+    /* Actual syntax elements for VOP (standard) */
+    int     predictionType;     /* VOP prediction type */
+    uint    timeInc;            /* VOP time increment (relative to last mtb) */
+    int     vopCoded;
+    int     roundingType;
+    int     intraDCVlcThr;
+    int16       quantizer;          /* VOP quantizer */
+    int     fcodeForward;       /* VOP dynamic range of motion vectors */
+    int     fcodeBackward;      /* VOP dynamic range of motion vectors */
+    int     refSelectCode;      /* enhancement layer reference select code */
+
+    /* H.263 parameters */
+    int     gobNumber;
+    int     gobFrameID;
+    int     temporalRef;        /* temporal reference, roll over at 256 */
+    int     ETR;
+} Vop;
+
+typedef struct tagVol
+{
+    int     volID;                  /* VOL identifier (for tracking) */
+    uint    timeIncrementResolution;/* VOL time increment */
+    int     nbitsTimeIncRes;        /* number of bits for time increment  */
+    uint        timeInc_offset;         /* timeInc offset for multiple VOP in a packet  */
+    uint32  moduloTimeBase;         /* internal decoder clock */
+    int     fixedVopRate;
+    BitstreamDecVideo   *bitstream; /* library bitstream buffer (input buffer) */
+
+    int     complexity_estDisable;  /* VOL disable complexity estimation */
+    int     complexity_estMethod;   /* VOL complexity estimation method */
+    Complexity_Est complexity;      /* complexity estimation flags      */
+
+    /* Error Resilience Flags */
+    int     errorResDisable;        /* VOL disable error resilence mode */
+    /*            (Use Resynch markers) */
+    int     useReverseVLC;          /* VOL reversible VLCs */
+    int     dataPartitioning;       /* VOL data partitioning */
+
+    /* Bit depth  */
+    uint    bitsPerPixel;
+//  int     mid_gray;               /* 2^(bits_per_pixel+2) */
+
+    /* Quantization related parameters */
+    int     quantPrecision;         /* Quantizer precision */
+    uint    quantType;              /* MPEG-4 or H.263 Quantization Type */
+    /* Added loaded quant mat,  05/22/2000 */
+    int     loadIntraQuantMat;      /* Load intra quantization matrix */
+    int     loadNonIntraQuantMat;   /* Load nonintra quantization matrix */
+    int     iqmat[64];              /* Intra quant.matrix */
+    int     niqmat[64];             /* Non-intra quant.matrix */
+
+    /* Parameters used for scalability */
+    int     scalability;            /* VOL scalability (flag) */
+    int     scalType;               /* temporal = 0, spatial = 1, both = 2 */
+
+    int     refVolID;               /* VOL id of reference VOL */
+    int     refSampDir;             /* VOL resol. of ref. VOL */
+    int     horSamp_n;              /* VOL hor. resampling of ref. VOL given by */
+    int     horSamp_m;              /*     sampfac = hor_samp_n/hor_samp_m      */
+    int     verSamp_n;              /* VOL ver. resampling of ref. VOL given by */
+    int     verSamp_m;              /*     sampfac = ver_samp_n/ver_samp_m      */
+    int     enhancementType;        /* VOL type of enhancement layer */
+    /* profile and level */
+    int32   profile_level_id;       /* 8-bit profile and level */ //  6/17/04
+
+} Vol;
+
+
+typedef int16 typeMBStore[6][NCOEFF_BLOCK];
+
+typedef struct tagMacroBlock
+{
+    typeMBStore         block;              /* blocks */         /*  ACDC */
+    uint8   pred_block[384];        /* prediction block,  Aug 3,2005 */
+    uint8   bitmapcol[6][8];
+    uint8   bitmaprow[6];
+    int     no_coeff[6];
+    int     DCScalarLum;                        /* Luminance DC Scalar */
+    int     DCScalarChr;                        /* Chrominance DC Scalar */
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    int direction;
+#endif
+} MacroBlock;
+
+typedef struct tagHeaderInfoDecVideo
+{
+    uint8       *Mode;              /* Modes INTRA/INTER/etc. */
+    uint8       *CBP;               /* MCBPC/CBPY stuff */
+} HeaderInfoDecVideo;
+
+
+/************************************************************/
+/*                  VLC structures                          */
+/************************************************************/
+typedef struct tagTcoef
+{
+    uint last;
+    uint run;
+    int level;
+    uint sign;
+} Tcoef, *LPTcoef;
+
+
+
+typedef struct tagVLCtab
+{
+    int32 val;
+    int32 len;
+} VLCtab, *LPVLCtab;
+
+typedef struct tagVLCshorttab
+{
+    int16 val;
+    int16 len;
+} VLCshorttab, *LPVLCshorttab ; /* for space saving, Antoine Nguyen*/
+
+typedef struct tagVLCtab2
+{
+    uint8 run;
+    uint8 level;
+    uint8 last;
+    uint8 len;
+} VLCtab2, *LPVLCtab2;  /* 10/24/2000 */
+
+/* This type is designed for fast access of DC/AC */
+/*    prediction data.  If the compiler is smart  */
+/*    enough, it will use shifting for indexing.  */
+/*     04/14/2000.                              */
+
+typedef int16 typeDCStore[6];   /*  ACDC */
+typedef int16 typeDCACStore[4][8];
+
+
+
+/* Global structure that can be passed around */
+typedef struct tagVideoDecData
+{
+    BitstreamDecVideo   *bitstream; /* library bitstream buffer (input buffer) */
+    /* Data For Layers (Scalability) */
+    Vol             **vol;                  /* Data stored for each VOL */
+
+    /* Data used for reconstructing frames */
+    Vop             *currVop;               /* Current VOP (frame)  */
+    Vop             *prevVop;               /* Previous VOP (frame) */
+    /* Data used to facilitate multiple layer decoding.   05/04/2000 */
+    Vop             *prevEnhcVop;           /* New change to rid of memcpy().  04/24/2001 */
+    Vop             **vopHeader;            /* one for each layer.   08/29/2000 */
+
+    /* I/O structures */
+    MacroBlock      *mblock;                    /* Macroblock data structure */
+    uint8           *acPredFlag;                /*  */
+
+    /* scratch memory used in data partitioned mode */
+    typeDCStore     *predDC;        /*  The DC coeffs for each MB */
+    typeDCACStore   *predDCAC_row;
+    typeDCACStore   *predDCAC_col;
+
+    int             usePrevQP;              /* running QP decision switch */
+    uint8           *sliceNo;               /* Slice indicator for each MB  */
+    /*     changed this to a 1D   */
+    /*    array for optimization    */
+    MOT             *motX;                  /* Motion vector in X direction */
+    MOT             *motY;                  /* Motion vector in Y direction */
+    HeaderInfoDecVideo  headerInfo;         /* MB Header information */
+    int16           *QPMB;                  /* Quantizer value for each MB */
+
+    uint8           *pstprcTypCur;          /* Postprocessing type for current frame */
+    uint8           *pstprcTypPrv;          /* Postprocessing type for previous frame */
+    /* scratch memory used in all modes */
+    int             mbnum;                      /*  Macroblock number */
+    uint            mbnum_row;
+    int             mbnum_col;
+    /* I added these variables since they are used a lot.   04/13/2000 */
+    int     nMBPerRow, nMBPerCol;   /* number of MBs in each row & column    */
+    int     nTotalMB;
+    /* for short video header */
+    int     nMBinGOB;               /* number of MBs in GOB,  05/22/00 */
+    int     nGOBinVop;              /* number of GOB in Vop   05/22/00 */
+    /* VOL Dimensions */
+    int     width;                  /* Width */
+    int     height;                 /* Height */
+    int     displayWidth;               /* Handle image whose size is not a multiple of 16. */
+    int     displayHeight;              /*   This is the actual size.   08/09/2000        */
+    int32   size;
+    /* Miscellaneous data points to be passed */
+    int             frame_idx;              /* Current frame ID */
+    int             frameRate;              /* Output frame Rate (over 10 seconds) */
+    int32           duration;
+    uint32          currTimestamp;
+    int             currLayer;              /* Current frame layer  */
+    int     shortVideoHeader;       /* shortVideoHeader mode */
+    int     intra_acdcPredDisable;  /* VOL disable INTRA DC prediction */
+    int             numberOfLayers;         /* Number of Layers */
+    /* Frame to be used for concealment     07/07/2001 */
+    uint8           *concealFrame;
+    int             vop_coding_type;
+    /* framerate and bitrate statistics counters.   08/23/2000 */
+    int32           nBitsPerVop[BITRATE_AVERAGE_WINDOW];
+    uint32          prevTimestamp[BITRATE_AVERAGE_WINDOW];
+    int     nBitsForMBID;           /* how many bits required for MB number? */
+    /* total data memory used by the docder library.   08/23/2000 */
+    int32           memoryUsage;
+
+    /* flag to turn on/off error concealment or soft decoding */
+    int errorConcealment;
+
+    /* Application controls */
+    VideoDecControls    *videoDecControls;
+    int                 postFilterType;     /* Postfilter mode  04/25/00 */
+
+
+
+    PV_STATUS(*vlcDecCoeffIntra)(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra_luma*/);
+    PV_STATUS(*vlcDecCoeffInter)(BitstreamDecVideo *stream, Tcoef *pTcoef);
+    int                 initialized;
+
+    /* Annex IJKT */
+    int     deblocking;
+    int     slice_structure;
+    int     modified_quant;
+    int     advanced_INTRA;
+    int16 QP_CHR;  /* ANNEX_T */
+} VideoDecData;
+
+/* for fast VLC+Dequant  10/12/2000*/
+typedef int (*VlcDequantBlockFuncP)(void *video, int comp, int switched,
+                                    uint8 *bitmaprow, uint8 *bitmapcol);
+
+//////////////////////////////////////////////////////////////
+//                  Decoder structures                      //
+//////////////////////////////////////////////////////////////
+#endif /* _MP4LIB_INT_H_ */
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/packet_util.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/packet_util.cpp
new file mode 100644
index 0000000..48414d7
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/packet_util.cpp
@@ -0,0 +1,252 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h"
+#include "vlc_decode.h"
+#include "bitstream.h"
+
+
+/***********************************************************CommentBegin******
+*       04/13/2000 : initial modification to the new PV-Decoder
+*                            Lib format.
+*       04/16/2001 : Removed PV_END_OF_BUFFER case, error resilience
+***********************************************************CommentEnd********/
+PV_STATUS PV_ReadVideoPacketHeader(VideoDecData *video, int *next_MB)
+{
+    PV_STATUS status;
+    Vol *currVol = video->vol[video->currLayer];
+    Vop *currVop = video->currVop;
+    BitstreamDecVideo *stream = video->bitstream;
+    int fcode_forward;
+    int resync_marker_length;
+    int nbits = video->nBitsForMBID;
+    uint32 tmpvar32;
+    uint tmpvar16;
+    int16 quantizer;
+    int nTotalMB = video->nTotalMB;
+
+    fcode_forward = currVop->fcodeForward;
+    resync_marker_length = 17;
+
+    if (currVop->predictionType != I_VOP) resync_marker_length = 16 + fcode_forward;
+
+    status = PV_BitstreamShowBitsByteAlign(stream, resync_marker_length, &tmpvar32);
+    /*  if (status != PV_SUCCESS && status != PV_END_OF_BUFFER) return status; */
+    if (tmpvar32 == RESYNC_MARKER)
+    {
+//      DecNextStartCode(stream);
+        PV_BitstreamByteAlign(stream);
+        BitstreamReadBits32(stream, resync_marker_length);
+
+        *next_MB = (int) BitstreamReadBits16(stream, nbits);
+//      if (*next_MB <= video->mbnum)   /*  needs more investigation */
+//          *next_MB = video->mbnum+1;
+
+        if (*next_MB >= nTotalMB)  /* fix  04/05/01 */
+        {
+            *next_MB = video->mbnum + 1;
+            if (*next_MB >= nTotalMB)    /* this check is needed  */
+                *next_MB = nTotalMB - 1;
+        }
+        quantizer = (int16) BitstreamReadBits16(stream, currVol->quantPrecision);
+        if (quantizer == 0) return PV_FAIL;        /*  04/03/01 */
+
+        currVop->quantizer = quantizer;
+
+        /* if we have HEC, read some redundant VOP header information */
+        /* this part needs improvement  04/05/01 */
+        if (BitstreamRead1Bits(stream))
+        {
+            int time_base = -1;
+
+            /* modulo_time_base (? bits) */
+            do
+            {
+                time_base++;
+                tmpvar16 = BitstreamRead1Bits(stream);
+            }
+            while (tmpvar16 == 1);
+
+            /* marker bit */
+            BitstreamRead1Bits(stream);
+
+            /* vop_time_increment (1-15 bits) */
+            BitstreamReadBits16(stream, currVol->nbitsTimeIncRes);
+
+            /* marker bit */
+            BitstreamRead1Bits(stream);
+
+            /* vop_prediction_type (2 bits) */
+            BitstreamReadBits16(stream, 2);
+
+            /* Added intra_dc_vlc_thr reading  */
+            BitstreamReadBits16(stream, 3);
+
+            /* fcodes */
+            if (currVop->predictionType != I_VOP)
+            {
+                fcode_forward = (int) BitstreamReadBits16(stream, 3);
+
+                if (currVop->predictionType == B_VOP)
+                {
+                    BitstreamReadBits16(stream, 3);
+                }
+            }
+
+        }
+    }
+    else
+    {
+        PV_BitstreamByteAlign(stream);  /*  */
+        status = BitstreamCheckEndBuffer(stream);   /* return end_of_VOP  03/30/01 */
+        if (status != PV_SUCCESS)
+        {
+            return status;
+        }
+        status = BitstreamShowBits32HC(stream, &tmpvar32);   /*  07/07/01 */
+        /* -16 = 0xFFFFFFF0*/
+        if ((tmpvar32 & 0xFFFFFFF0) == VISUAL_OBJECT_SEQUENCE_START_CODE) /* start code mask 00 00 01 */
+
+        {
+            /* we don't have to check for legl stuffing here.   05/08/2000 */
+            return PV_END_OF_VOP;
+        }
+        else
+        {
+            return PV_FAIL;
+        }
+    }
+
+    return PV_SUCCESS;
+}
+
+
+
+/***********************************************************CommentBegin******
+*       3/10/00  : initial modification to the
+*                new PV-Decoder Lib format.
+*       04/17/01 : remove PV_END_OF_BUFFER, error checking
+***********************************************************CommentEnd********/
+PV_STATUS PV_GobHeader(VideoDecData *video)
+{
+    uint32 tmpvar;
+    Vop *currVop = video->currVop;
+    BitstreamDecVideo *stream = video->bitstream;
+    int quantPrecision = 5;
+    int16 quantizer;
+
+    BitstreamShowBits32(stream, GOB_RESYNC_MARKER_LENGTH, &tmpvar);
+
+    if (tmpvar != GOB_RESYNC_MARKER)
+    {
+        PV_BitstreamShowBitsByteAlign(stream, GOB_RESYNC_MARKER_LENGTH, &tmpvar);
+
+        if (tmpvar != GOB_RESYNC_MARKER)
+        {
+            return PV_FAIL;
+        }
+        else
+            PV_BitstreamByteAlign(stream);  /* if bytealigned GOBHEADER search is performed */
+        /* then no more noforcestuffing  */
+    }
+
+    /* we've got a GOB header info here */
+    BitstreamShowBits32(stream, GOB_RESYNC_MARKER_LENGTH + 5, &tmpvar);
+    tmpvar &= 0x1F;
+
+    if (tmpvar == 0)
+    {
+        return PV_END_OF_VOP;
+    }
+
+    if (tmpvar == 31)
+    {
+        PV_BitstreamFlushBits(stream, GOB_RESYNC_MARKER_LENGTH + 5);
+        BitstreamByteAlignNoForceStuffing(stream);
+        return PV_END_OF_VOP;
+    }
+
+    PV_BitstreamFlushBits(stream, GOB_RESYNC_MARKER_LENGTH + 5);
+    currVop->gobNumber = (int) tmpvar;
+    if (currVop->gobNumber >= video->nGOBinVop) return PV_FAIL;
+    currVop->gobFrameID = (int) BitstreamReadBits16(stream, 2);
+    quantizer = (int16) BitstreamReadBits16(stream, quantPrecision);
+    if (quantizer == 0)   return PV_FAIL;         /*  04/03/01 */
+
+    currVop->quantizer = quantizer;
+    return PV_SUCCESS;
+}
+#ifdef PV_ANNEX_IJKT_SUPPORT
+PV_STATUS PV_H263SliceHeader(VideoDecData *video, int *next_MB)
+{
+    PV_STATUS status;
+    uint32 tmpvar;
+    Vop *currVop = video->currVop;
+    BitstreamDecVideo *stream = video->bitstream;
+    int nTotalMB = video->nTotalMB;
+    int16 quantizer;
+
+    PV_BitstreamShowBitsByteAlignNoForceStuffing(stream, 17, &tmpvar);
+    if (tmpvar == RESYNC_MARKER)
+    {
+        BitstreamByteAlignNoForceStuffing(stream);
+        PV_BitstreamFlushBits(stream, 17);
+        if (!BitstreamRead1Bits(stream))
+        {
+            return PV_FAIL;
+        }
+        *next_MB = BitstreamReadBits16(stream, video->nBitsForMBID);
+        if (*next_MB >= nTotalMB)  /* fix  04/05/01 */
+        {
+            *next_MB = video->mbnum + 1;
+            if (*next_MB >= nTotalMB)    /* this check is needed  */
+                *next_MB = nTotalMB - 1;
+        }
+        /* we will not parse sebp2 for large pictures 3GPP */
+        quantizer = (int16) BitstreamReadBits16(stream, 5);
+        if (quantizer == 0) return PV_FAIL;
+
+        currVop->quantizer = quantizer;
+        if (!BitstreamRead1Bits(stream))
+        {
+            return PV_FAIL;
+        }
+        currVop->gobFrameID = (int) BitstreamReadBits16(stream, 2);
+    }
+    else
+    {
+        status = BitstreamCheckEndBuffer(stream);   /* return end_of_VOP  03/30/01 */
+        if (status != PV_SUCCESS)
+        {
+            return status;
+        }
+        PV_BitstreamShowBitsByteAlign(stream, SHORT_VIDEO_START_MARKER_LENGTH, &tmpvar);
+
+        if (tmpvar == SHORT_VIDEO_START_MARKER)
+        {
+            /* we don't have to check for legal stuffing here.   05/08/2000 */
+            return PV_END_OF_VOP;
+        }
+        else
+        {
+            return PV_FAIL;
+        }
+    }
+    return PV_SUCCESS;
+}
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/post_filter.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/post_filter.cpp
new file mode 100644
index 0000000..b36050c
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/post_filter.cpp
@@ -0,0 +1,585 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+
+#include    "mp4dec_lib.h"
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+#include    "motion_comp.h"
+#include "mbtype_mode.h"
+const static int STRENGTH_tab[] = {0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 12};
+#endif
+
+#ifdef PV_POSTPROC_ON
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+void PostFilter(
+    VideoDecData *video,
+    int filter_type,
+    uint8 *output)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    uint8 *pp_mod;
+    int16 *QP_store;
+    int combined_with_deblock_filter;
+    int nTotalMB = video->nTotalMB;
+    int width, height;
+    int32 size;
+    int softDeblocking;
+    uint8 *decodedFrame = video->videoDecControls->outputFrame;
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    width = video->width;
+    height = video->height;
+    size = (int32)width * height;
+
+    oscl_memcpy(output, decodedFrame, size);
+    oscl_memcpy(output + size, decodedFrame + size, (size >> 2));
+    oscl_memcpy(output + size + (size >> 2), decodedFrame + size + (size >> 2), (size >> 2));
+
+    if (filter_type == 0)
+        return;
+
+    /* The softDecoding cutoff corresponds to ~93000 bps for QCIF 15fps clip  */
+    if (PVGetDecBitrate(video->videoDecControls) > (100*video->frameRate*(size >> 12)))  // MC_sofDeblock
+        softDeblocking = FALSE;
+    else
+        softDeblocking = TRUE;
+
+    combined_with_deblock_filter = filter_type & PV_DEBLOCK;
+    QP_store = video->QPMB;
+
+    /* Luma */
+    pp_mod = video->pstprcTypCur;
+
+    if ((filter_type & PV_DEBLOCK) && (filter_type & PV_DERING))
+    {
+        CombinedHorzVertRingFilter(output, width, height, QP_store, 0, pp_mod);
+    }
+    else
+    {
+        if (filter_type & PV_DEBLOCK)
+        {
+            if (softDeblocking)
+            {
+                CombinedHorzVertFilter(output, width, height,
+                                       QP_store, 0, pp_mod);
+            }
+            else
+            {
+                CombinedHorzVertFilter_NoSoftDeblocking(output, width, height,
+                                                        QP_store, 0, pp_mod);
+            }
+        }
+        if (filter_type & PV_DERING)
+        {
+            Deringing_Luma(output, width, height, QP_store,
+                           combined_with_deblock_filter, pp_mod);
+
+        }
+    }
+
+    /* Chroma */
+
+    pp_mod += (nTotalMB << 2);
+    output += size;
+
+    if ((filter_type & PV_DEBLOCK) && (filter_type & PV_DERING))
+    {
+        CombinedHorzVertRingFilter(output, (int)(width >> 1), (int)(height >> 1), QP_store, (int) 1, pp_mod);
+    }
+    else
+    {
+        if (filter_type & PV_DEBLOCK)
+        {
+            if (softDeblocking)
+            {
+                CombinedHorzVertFilter(output, (int)(width >> 1),
+                                       (int)(height >> 1), QP_store, (int) 1, pp_mod);
+            }
+            else
+            {
+                CombinedHorzVertFilter_NoSoftDeblocking(output, (int)(width >> 1),
+                                                        (int)(height >> 1), QP_store, (int) 1, pp_mod);
+            }
+        }
+        if (filter_type & PV_DERING)
+        {
+            Deringing_Chroma(output, (int)(width >> 1),
+                             (int)(height >> 1), QP_store,
+                             combined_with_deblock_filter, pp_mod);
+        }
+    }
+
+    pp_mod += nTotalMB;
+    output += (size >> 2);
+
+    if ((filter_type & PV_DEBLOCK) && (filter_type & PV_DERING))
+    {
+        CombinedHorzVertRingFilter(output, (int)(width >> 1), (int)(height >> 1), QP_store, (int) 1, pp_mod);
+    }
+    else
+    {
+        if (filter_type & PV_DEBLOCK)
+        {
+            if (softDeblocking)
+            {
+                CombinedHorzVertFilter(output, (int)(width >> 1),
+                                       (int)(height >> 1), QP_store, (int) 1, pp_mod);
+            }
+            else
+            {
+                CombinedHorzVertFilter_NoSoftDeblocking(output, (int)(width >> 1),
+                                                        (int)(height >> 1), QP_store, (int) 1, pp_mod);
+            }
+        }
+        if (filter_type & PV_DERING)
+        {
+            Deringing_Chroma(output, (int)(width >> 1),
+                             (int)(height >> 1), QP_store,
+                             combined_with_deblock_filter, pp_mod);
+        }
+    }
+
+    /*  swap current pp_mod to prev_frame pp_mod */
+    pp_mod = video->pstprcTypCur;
+    video->pstprcTypCur = video->pstprcTypPrv;
+    video->pstprcTypPrv = pp_mod;
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+#endif
+
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+void H263_Deblock(uint8 *rec,
+                  int width,
+                  int height,
+                  int16 *QP_store,
+                  uint8 *mode,
+                  int chr, int annex_T)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int i, j, k;
+    uint8 *rec_y;
+    int tmpvar;
+    int mbnum, strength, A_D, d1_2, d1, d2, A, B, C, D, b_size;
+    int d, offset, nMBPerRow, nMBPerCol, width2 = (width << 1);
+    /* MAKE SURE I-VOP INTRA MACROBLOCKS ARE SET TO NON-SKIPPED MODE*/
+    mbnum = 0;
+
+    if (chr)
+    {
+        nMBPerRow = width >> 3;
+        nMBPerCol = height >> 3;
+        b_size = 8;
+    }
+    else
+    {
+        nMBPerRow = width >> 4;
+        nMBPerCol = height >> 4;
+        b_size = 16;
+    }
+
+
+    /********************************* VERTICAL FILTERING ****************************/
+    /* vertical filtering of mid sections no need to check neighboring QP's etc */
+    if (!chr)
+    {
+        rec_y = rec + (width << 3);
+        for (i = 0; i < (height >> 4); i++)
+        {
+            for (j = 0; j < (width >> 4); j++)
+            {
+                if (mode[mbnum] != MODE_SKIPPED)
+                {
+                    k = 16;
+                    strength = STRENGTH_tab[QP_store[mbnum]];
+                    while (k--)
+                    {
+                        A =  *(rec_y - width2);
+                        D = *(rec_y + width);
+                        A_D = A - D;
+                        C = *rec_y;
+                        B = *(rec_y - width);
+                        d = (((C - B) << 2) + A_D);
+
+                        if (d < 0)
+                        {
+                            d1 = -(-d >> 3);
+                            if (d1 < -(strength << 1))
+                            {
+                                d1 = 0;
+                            }
+                            else if (d1 < -strength)
+                            {
+                                d1 = -d1 - (strength << 1);
+                            }
+                            d1_2 = -d1 >> 1;
+                        }
+                        else
+                        {
+                            d1 = d >> 3;
+                            if (d1 > (strength << 1))
+                            {
+                                d1 = 0;
+                            }
+                            else if (d1 > strength)
+                            {
+                                d1 = (strength << 1) - d1;
+                            }
+                            d1_2 = d1 >> 1;
+                        }
+
+                        if (A_D < 0)
+                        {
+                            d2 = -(-A_D >> 2);
+                            if (d2 < -d1_2)
+                            {
+                                d2 = -d1_2;
+                            }
+                        }
+                        else
+                        {
+                            d2 = A_D >> 2;
+                            if (d2 > d1_2)
+                            {
+                                d2 = d1_2;
+                            }
+                        }
+
+                        *(rec_y - width2) = A - d2;
+                        tmpvar = B + d1;
+                        CLIP_RESULT(tmpvar)
+                        *(rec_y - width) = tmpvar;
+                        tmpvar = C - d1;
+                        CLIP_RESULT(tmpvar)
+                        *rec_y = tmpvar;
+                        *(rec_y + width) = D + d2;
+                        rec_y++;
+                    }
+                }
+                else
+                {
+                    rec_y += b_size;
+                }
+                mbnum++;
+            }
+            rec_y += (15 * width);
+
+        }
+    }
+
+    /* VERTICAL boundary blocks */
+
+
+    rec_y = rec + width * b_size;
+
+    mbnum = nMBPerRow;
+    for (i = 0; i < nMBPerCol - 1; i++)
+    {
+        for (j = 0; j < nMBPerRow; j++)
+        {
+            if (mode[mbnum] != MODE_SKIPPED || mode[mbnum - nMBPerRow] != MODE_SKIPPED)
+            {
+                k = b_size;
+                if (mode[mbnum] != MODE_SKIPPED)
+                {
+                    strength = STRENGTH_tab[(annex_T ?  MQ_chroma_QP_table[QP_store[mbnum]] : QP_store[mbnum])];
+                }
+                else
+                {
+                    strength = STRENGTH_tab[(annex_T ?  MQ_chroma_QP_table[QP_store[mbnum - nMBPerRow]] : QP_store[mbnum - nMBPerRow])];
+                }
+
+                while (k--)
+                {
+                    A =  *(rec_y - width2);
+                    D =  *(rec_y + width);
+                    A_D = A - D;
+                    C = *rec_y;
+                    B = *(rec_y - width);
+                    d = (((C - B) << 2) + A_D);
+
+                    if (d < 0)
+                    {
+                        d1 = -(-d >> 3);
+                        if (d1 < -(strength << 1))
+                        {
+                            d1 = 0;
+                        }
+                        else if (d1 < -strength)
+                        {
+                            d1 = -d1 - (strength << 1);
+                        }
+                        d1_2 = -d1 >> 1;
+                    }
+                    else
+                    {
+                        d1 = d >> 3;
+                        if (d1 > (strength << 1))
+                        {
+                            d1 = 0;
+                        }
+                        else if (d1 > strength)
+                        {
+                            d1 = (strength << 1) - d1;
+                        }
+                        d1_2 = d1 >> 1;
+                    }
+
+                    if (A_D < 0)
+                    {
+                        d2 = -(-A_D >> 2);
+                        if (d2 < -d1_2)
+                        {
+                            d2 = -d1_2;
+                        }
+                    }
+                    else
+                    {
+                        d2 = A_D >> 2;
+                        if (d2 > d1_2)
+                        {
+                            d2 = d1_2;
+                        }
+                    }
+
+                    *(rec_y - width2) = A - d2;
+                    tmpvar = B + d1;
+                    CLIP_RESULT(tmpvar)
+                    *(rec_y - width) = tmpvar;
+                    tmpvar = C - d1;
+                    CLIP_RESULT(tmpvar)
+                    *rec_y = tmpvar;
+                    *(rec_y + width) = D + d2;
+                    rec_y++;
+                }
+            }
+            else
+            {
+                rec_y += b_size;
+            }
+            mbnum++;
+        }
+        rec_y += ((b_size - 1) * width);
+
+    }
+
+
+    /***************************HORIZONTAL FILTERING ********************************************/
+    mbnum = 0;
+    /* HORIZONTAL INNER */
+    if (!chr)
+    {
+        rec_y = rec + 8;
+        offset = width * b_size - b_size;
+
+        for (i = 0; i < nMBPerCol; i++)
+        {
+            for (j = 0; j < nMBPerRow; j++)
+            {
+                if (mode[mbnum] != MODE_SKIPPED)
+                {
+                    k = 16;
+                    strength = STRENGTH_tab[QP_store[mbnum]];
+                    while (k--)
+                    {
+                        A =  *(rec_y - 2);
+                        D =  *(rec_y + 1);
+                        A_D = A - D;
+                        C = *rec_y;
+                        B = *(rec_y - 1);
+                        d = (((C - B) << 2) + A_D);
+
+                        if (d < 0)
+                        {
+                            d1 = -(-d >> 3);
+                            if (d1 < -(strength << 1))
+                            {
+                                d1 = 0;
+                            }
+                            else if (d1 < -strength)
+                            {
+                                d1 = -d1 - (strength << 1);
+                            }
+                            d1_2 = -d1 >> 1;
+                        }
+                        else
+                        {
+                            d1 = d >> 3;
+                            if (d1 > (strength << 1))
+                            {
+                                d1 = 0;
+                            }
+                            else if (d1 > strength)
+                            {
+                                d1 = (strength << 1) - d1;
+                            }
+                            d1_2 = d1 >> 1;
+                        }
+
+                        if (A_D < 0)
+                        {
+                            d2 = -(-A_D >> 2);
+                            if (d2 < -d1_2)
+                            {
+                                d2 = -d1_2;
+                            }
+                        }
+                        else
+                        {
+                            d2 = A_D >> 2;
+                            if (d2 > d1_2)
+                            {
+                                d2 = d1_2;
+                            }
+                        }
+
+                        *(rec_y - 2) = A - d2;
+                        tmpvar = B + d1;
+                        CLIP_RESULT(tmpvar)
+                        *(rec_y - 1) = tmpvar;
+                        tmpvar = C - d1;
+                        CLIP_RESULT(tmpvar)
+                        *rec_y = tmpvar;
+                        *(rec_y + 1) = D + d2;
+                        rec_y += width;
+                    }
+                    rec_y -= offset;
+                }
+                else
+                {
+                    rec_y += b_size;
+                }
+                mbnum++;
+            }
+            rec_y += (15 * width);
+
+        }
+    }
+
+
+
+    /* HORIZONTAL EDGE */
+    rec_y = rec + b_size;
+    offset = width * b_size - b_size;
+    mbnum = 1;
+    for (i = 0; i < nMBPerCol; i++)
+    {
+        for (j = 0; j < nMBPerRow - 1; j++)
+        {
+            if (mode[mbnum] != MODE_SKIPPED || mode[mbnum-1] != MODE_SKIPPED)
+            {
+                k = b_size;
+                if (mode[mbnum] != MODE_SKIPPED)
+                {
+                    strength = STRENGTH_tab[(annex_T ?  MQ_chroma_QP_table[QP_store[mbnum]] : QP_store[mbnum])];
+                }
+                else
+                {
+                    strength = STRENGTH_tab[(annex_T ?  MQ_chroma_QP_table[QP_store[mbnum - 1]] : QP_store[mbnum - 1])];
+                }
+
+                while (k--)
+                {
+                    A =  *(rec_y - 2);
+                    D =  *(rec_y + 1);
+                    A_D = A - D;
+                    C = *rec_y;
+                    B = *(rec_y - 1);
+                    d = (((C - B) << 2) + A_D);
+
+                    if (d < 0)
+                    {
+                        d1 = -(-d >> 3);
+                        if (d1 < -(strength << 1))
+                        {
+                            d1 = 0;
+                        }
+                        else if (d1 < -strength)
+                        {
+                            d1 = -d1 - (strength << 1);
+                        }
+                        d1_2 = -d1 >> 1;
+                    }
+                    else
+                    {
+                        d1 = d >> 3;
+                        if (d1 > (strength << 1))
+                        {
+                            d1 = 0;
+                        }
+                        else if (d1 > strength)
+                        {
+                            d1 = (strength << 1) - d1;
+                        }
+                        d1_2 = d1 >> 1;
+                    }
+
+                    if (A_D < 0)
+                    {
+                        d2 = -(-A_D >> 2);
+                        if (d2 < -d1_2)
+                        {
+                            d2 = -d1_2;
+                        }
+                    }
+                    else
+                    {
+                        d2 = A_D >> 2;
+                        if (d2 > d1_2)
+                        {
+                            d2 = d1_2;
+                        }
+                    }
+
+                    *(rec_y - 2) = A - d2;
+                    tmpvar = B + d1;
+                    CLIP_RESULT(tmpvar)
+                    *(rec_y - 1) = tmpvar;
+                    tmpvar = C - d1;
+                    CLIP_RESULT(tmpvar)
+                    *rec_y = tmpvar;
+                    *(rec_y + 1) = D + d2;
+                    rec_y += width;
+                }
+                rec_y -= offset;
+            }
+            else
+            {
+                rec_y += b_size;
+            }
+            mbnum++;
+        }
+        rec_y += ((width * (b_size - 1)) + b_size);
+        mbnum++;
+    }
+
+    return;
+}
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/post_proc.h b/media/libstagefright/codecs/m4v_h263/dec/src/post_proc.h
new file mode 100644
index 0000000..091fdaf
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/post_proc.h
@@ -0,0 +1,75 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#ifndef post_proc_H
+#define post_proc_H
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include    "mp4dec_lib.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here.
+----------------------------------------------------------------------------*/
+#define UPDATE_PV_MAXPV_MIN(p,max,min) if ((p) > max) max=(p); else if ((p) < min) min = (p);
+
+#define     INDEX(x,thr)    (((x)>=thr)?1:0)
+#define     BLKSIZE     8
+#define     MBSIZE      16
+#define     DERING_THR  16
+
+/* version for fast Deblock filtering*/
+#define     KTh     4  /*threshold for soft filtering*/
+#define     KThH    4  /*threshold for hard filtering */
+
+#define     NoMMX
+
+/*----------------------------------------------------------------------------
+; EXTERNAL VARIABLES REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; SIMPLE TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; ENUMERATED TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; STRUCTURES TYPEDEF'S
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; GLOBAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; END
+----------------------------------------------------------------------------*/
+#endif
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/post_proc_semaphore.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/post_proc_semaphore.cpp
new file mode 100644
index 0000000..3abc6be
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/post_proc_semaphore.cpp
@@ -0,0 +1,247 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    q_block = pointer to buffer of inverse quantized DCT coefficients of type
+              int for intra-VOP mode or buffer of residual data of type int
+              for inter-VOP mode
+
+ Local Stores/Buffers/Pointers Needed:
+    None
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Outputs:
+    postmode = post processing semaphore with the vertical deblocking,
+               horizontal deblocking, and deringing bits set up accordingly
+
+ Pointers and Buffers Modified:
+    None
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ This function sets up the postmode semaphore based on the contents of the
+ buffer pointed to by q_block. The function starts out with the assumption
+ that all entries of q_block, except for the first entry (q_block[0]), are
+ zero. This case can induce horizontal and vertical blocking artifacts,
+ therefore, both horizontal and vertical deblocking bits are enabled.
+
+ The following conditions are tested when setting up the horizontal/vertical
+ deblocking and deringing bits:
+ 1. When only the elements of the top row of the B_SIZE x B_SIZE block
+    (q_block[n], n = 0,..., B_SIZE-1) are non-zero, vertical blocking artifacts
+    may result, therefore, only the vertical deblocking bit is enabled.
+    Otherwise, the vertical deblocking bit is disabled.
+ 2. When only the elements of the far left column of the B_SIZE x B_SIZE block
+    (q_block[n*B_SIZE], n = 0, ..., B_SIZE-1) are non-zero, horizontal blocking
+    artifacts may result, therefore, only the horizontal deblocking bit is
+    enabled. Otherwise, the horizontal deblocking bit is disabled.
+ 3. If any non-zero elements exist in positions other than q_block[0],
+    q_block[1], or q_block[B_SIZE], the deringing bit is enabled. Otherwise,
+    it is disabled.
+
+ The 3 least significant bits of postmode defines vertical or horizontal
+ deblocking and deringing.
+
+ The valid values are shown below:
+ -------------------------------------------------------
+ |           Type                 | Enabled | Disabled |
+ -------------------------------------------------------
+ | Vertical Deblocking (Bit #0)   |    1    |     0    |
+ -------------------------------------------------------
+ | Horizontal Deblocking (Bit #1) |    1    |     0    |
+ -------------------------------------------------------
+ | Deringing (Bit #2)             |    1    |     0    |
+ -------------------------------------------------------
+
+*/
+
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include    "mp4dec_lib.h"
+#include    "mp4def.h"
+#include    "post_proc.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+#ifdef PV_POSTPROC_ON
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+int PostProcSemaphore(
+    int16 *q_block)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    int i, j;
+
+    /* Set default value to vertical and horizontal deblocking enabled */
+    /* Initial assumption is that only q_block[0] element is non-zero, */
+    /* therefore, vertical and horizontal deblocking bits are set to 1 */
+    int postmode = 0x3;
+
+    /*----------------------------------------------------------------------------
+    ; Function body here
+    ----------------------------------------------------------------------------*/
+    /* Vertical deblocking bit is enabled when only the entire top row of   */
+    /* the B_SIZE x B_SIZE block, i.e., q_block[n], n = 0,..., B_SIZE-1,    */
+    /* are non-zero. Since initial assumption is that all elements, except  */
+    /* q_block[0], is zero, we need to check the remaining elements in the  */
+    /* top row to  determine if all or some are non-zero.                   */
+    if (q_block[1] != 0)
+    {
+        /* At this point, q_block[0] and q_block[1] are non-zero, while */
+        /* q_block[n], n = 2,..., B_SIZE-1, are zero. Therefore, we     */
+        /* need to disable vertical deblocking                          */
+        postmode &= 0xE;
+    }
+
+    for (i = 2; i < B_SIZE; i++)
+    {
+        if (q_block[i])
+        {
+            /* Check if q_block[n], n = 2,..., B_SIZE-1, are non-zero.*/
+            /* If any of them turn out to be non-zero, we need to     */
+            /* disable vertical deblocking.                           */
+            postmode &= 0xE;
+
+            /* Deringing is enabled if any nonzero elements exist in */
+            /* positions other than q_block[0], q_block[1] or        */
+            /* q_block[B_SIZE].                                      */
+            postmode |= 0x4;
+
+            break;
+        }
+    }
+
+    /* Horizontal deblocking bit is enabled when only the entire far */
+    /* left column, i.e., q_block[n*B_SIZE], n = 0, ..., B_SIZE-1,   */
+    /* are non-zero. Since initial assumption is that all elements,  */
+    /* except q_block[0], is zero, we need to check the remaining    */
+    /* elements in the far left column to determine if all or some   */
+    /* are non-zero.                                                 */
+    if (q_block[B_SIZE])
+    {
+        /* At this point, only q_block[0] and q_block[B_SIZE] are non-zero, */
+        /* while q_block[n*B_SIZE], n = 2, 3,..., B_SIZE-1, are zero.       */
+        /* Therefore, we need to disable horizontal deblocking.             */
+        postmode &= 0xD;
+    }
+
+    for (i = 16; i < NCOEFF_BLOCK; i += B_SIZE)
+    {
+        if (q_block[i])
+        {
+            /* Check if q_block[n], n = 2*B_SIZE,...,(B_SIZE-1)*B_SIZE,  */
+            /* are non-zero. If any of them turn out to be non-zero,     */
+            /* we need to disable horizontal deblocking.                 */
+            postmode &= 0xD;
+
+            /* Deringing is enabled if any nonzero elements exist in */
+            /* positions other than q_block[0], q_block[1] or        */
+            /* q_block[B_SIZE].                                      */
+            postmode |= 0x4;
+
+            break;
+        }
+    }
+
+    /* At this point, only the first row and far left column elements */
+    /* have been tested. If deringing bit is still not set at this    */
+    /* point, check the rest of q_block to determine if the elements  */
+    /* are non-zero. If all elements, besides q_block[0], q_block[1], */
+    /* or q_block[B_SIZE] are non-zero, deringing bit must be set     */
+    if ((postmode & 0x4) == 0)
+    {
+        for (i = 1; i < B_SIZE; i++)
+        {
+            for (j = 1; j < B_SIZE; j++)
+            {
+                if (q_block[(i<<3)+j])
+                {
+                    /* At this point, q_block[0] and another q_block */
+                    /* element are non-zero, therefore, we need to   */
+                    /* disable vertical and horizontal deblocking    */
+                    postmode &= 0xC;
+
+                    /* Deringing is enabled if any nonzero elements exist in */
+                    /* positions other than q_block[0], q_block[1] or        */
+                    /* q_block[B_SIZE].                                      */
+                    postmode |= 0x4;
+
+                    /* Set outer FOR loop count to B_SIZE to get out of */
+                    /* outer FOR loop                                   */
+                    i = B_SIZE;
+
+                    /* Get out of inner FOR loop */
+                    break;
+                }
+            }
+        }
+    }
+
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return (postmode);
+}
+
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/pp_semaphore_chroma_inter.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/pp_semaphore_chroma_inter.cpp
new file mode 100644
index 0000000..7c20222
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/pp_semaphore_chroma_inter.cpp
@@ -0,0 +1,262 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    xpred = x-axis coordinate of the block used for prediction (int)
+    ypred = y-axis coordinate of the block used for prediction (int)
+    pp_dec_u = pointer to the post processing semaphore for chrominance
+               (uint8)
+    pstprcTypPrv = pointer the previous frame's post processing type
+                   (uint8)
+    dx = horizontal component of the motion vector (int)
+    dy = vertical component of the motion vector (int)
+    mvwidth = number of blocks per row in the luminance VOP (int)
+    height = luminance VOP height in pixels (int)
+    size = total number of pixel in the current luminance VOP (int)
+    mv_loc = flag indicating location of the motion compensated
+         (x,y) position with respect to the luminance MB (int);
+         0 -> inside MB, 1 -> outside MB
+    msk_deblock = flag indicating whether to perform deblocking
+              (msk_deblock = 0) or not (msk_deblock = 1) (uint8)
+
+ Local Stores/Buffers/Pointers Needed:
+    None
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Outputs:
+    None
+
+ Pointers and Buffers Modified:
+    pp_dec_u contents are the updated semaphore propagation data
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ This functions performs post processing semaphore propagation processing
+ after chrominance prediction in interframe processing mode.
+
+*/
+
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include    "mp4dec_api.h"
+#include    "mp4def.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+#ifdef PV_POSTPROC_ON
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    /*----------------------------------------------------------------------------
+    ; FUNCTION CODE
+    ----------------------------------------------------------------------------*/
+    void pp_semaphore_chroma_inter(
+        int xpred,      /* i */
+        int ypred,      /* i */
+        uint8   *pp_dec_u,  /* i/o */
+        uint8   *pstprcTypPrv,  /* i */
+        int dx,     /* i */
+        int dy,     /* i */
+        int mvwidth,    /* i */
+        int height,     /* i */
+        int32   size,       /* i */
+        int mv_loc,     /* i */
+        uint8   msk_deblock /* i */
+    )
+    {
+        /*----------------------------------------------------------------------------
+        ; Define all local variables
+        ----------------------------------------------------------------------------*/
+        int mmvy, mmvx, nmvy, nmvx;
+        uint8 *pp_prev1, *pp_prev2, *pp_prev3, *pp_prev4;
+
+        /*----------------------------------------------------------------------------
+        ; Function body here
+        ----------------------------------------------------------------------------*/
+
+        /* 09/28/2000, modify semaphore propagation to */
+        /* accommodate smart indexing */
+        mmvx = xpred >> 4;  /* block x coor */
+        nmvx = mmvx;
+
+        mmvy = ypred >> 4;  /* block y coor */
+        nmvy = mmvy;
+
+        /* Check if MV is outside the frame */
+        if (mv_loc == 1)
+        {
+            /* Perform boundary check */
+            if (nmvx < 0)
+            {
+                nmvx = 0;
+            }
+            else if (nmvx > mvwidth - 1)
+            {
+                nmvx = mvwidth - 1;
+            }
+
+            if (nmvy < 0)
+            {
+                nmvy = 0;
+            }
+            else if (nmvy > (height >> 4) - 1)
+            {
+                nmvy = (height >> 4) - 1;
+            }
+        }
+
+        /* Calculate pointer to first chrominance b semaphores in       */
+        /* pstprcTypPrv, i.e., first chrominance b semaphore is in      */
+        /* (pstprcTypPrv + (size>>6)).                  */
+        /* Since total number of chrominance blocks per row in a VOP    */
+        /* is half of the total number of luminance blocks per row in a */
+        /* VOP, we use (mvwidth >> 1) when calculating the row offset.  */
+        pp_prev1 = pstprcTypPrv + (size >> 6) + nmvx + nmvy * (mvwidth >> 1) ;
+
+        /* Check if MV is a multiple of 16 */
+        /*  1/5/01, make sure it doesn't go out of bound */
+        if (((dy&0xF) != 0) && (mmvy + 1 < (height >> 4) - 1))
+        {   /* dy is not a multiple of 16 */
+
+            /* pp_prev3 is the block below pp_prev1 block */
+            pp_prev3 = pp_prev1 + (mvwidth >> 1);
+        }
+        else
+        {   /* dy is a multiple of 16 */
+            pp_prev3 = pp_prev1;
+        }
+
+        /*  1/5/01, make sure it doesn't go out of bound */
+        if (((dx&0xF) != 0) && (mmvx + 1 < (mvwidth >> 1) - 1))
+        {   /* dx is not a multiple of 16 */
+
+            /* pp_prev2 is the block to the right of pp_prev1 block */
+            pp_prev2 = pp_prev1 + 1;
+
+            /* pp_prev4 is the block to the right of the block */
+            /* below pp_prev1 block                */
+            pp_prev4 = pp_prev3 + 1;
+        }
+        else
+        {   /* dx is a multiple of 16 */
+
+            pp_prev2 = pp_prev1;
+            pp_prev4 = pp_prev3;
+        }
+
+        /* Advance offset to location of first Chrominance R semaphore in */
+        /* pstprcTypPrv. Since the number of pixels in a Chrominance VOP  */
+        /* is (number of pixels in Luminance VOP/4), and there are 64     */
+        /* pixels in an 8x8 Chrominance block, the offset can be      */
+        /* calculated as:                         */
+        /*  mv_loc = (number of pixels in Luminance VOP/(4*64))   */
+        /*         = size/256 = size>>8               */
+        mv_loc = (size >> 8);
+
+        /*  11/3/00, change the propagation for deblocking */
+        if (msk_deblock == 0)
+        {
+
+            /* Deblocking semaphore propagation for Chrominance */
+            /* b semaphores                     */
+            *(pp_dec_u) = 0;
+
+            /* Advance offset to point to Chrominance r semaphores */
+            pp_dec_u += mv_loc;
+
+            /* Deblocking semaphore propagation for Chrominance */
+            /* r semaphores                     */
+            *(pp_dec_u) = 0;
+        }
+        else
+        {
+            /* Deringing semaphore propagation for Chrominance B block */
+            if ((*(pp_dec_u)&4) == 0)
+            {
+                *(pp_dec_u) |= ((*(pp_prev1) | *(pp_prev2) |
+                                 *(pp_prev3) | *(pp_prev4)) & 0x4);
+            }
+
+            /* Advance offset to point to Chrominance r semaphores */
+            pp_dec_u += mv_loc;
+            pp_prev1 += mv_loc;
+            pp_prev2 += mv_loc;
+            pp_prev3 += mv_loc;
+            pp_prev4 += mv_loc;
+
+            /* Deringing semaphore propagation for Chrominance R */
+            if ((*(pp_dec_u)&4) == 0)
+            {
+                *(pp_dec_u) |= ((*(pp_prev1) | *(pp_prev2) |
+                                 *(pp_prev3) | *(pp_prev4)) & 0x4);
+            }
+        }
+
+        /*----------------------------------------------------------------------------
+        ; Return nothing or data or data pointer
+        ----------------------------------------------------------------------------*/
+        return;
+    }
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/pp_semaphore_luma.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/pp_semaphore_luma.cpp
new file mode 100644
index 0000000..b3a1ebd
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/pp_semaphore_luma.cpp
@@ -0,0 +1,378 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+------------------------------------------------------------------------------
+ INPUT AND OUTPUT DEFINITIONS
+
+ Inputs:
+    xpred = x-axis coordinate of the MB used for prediction (int)
+    ypred = y-axis coordinate of the MB used for prediction (int)
+    pp_dec_y = pointer to the post processing semaphore for current
+           luminance frame (uint8)
+    pstprcTypPrv = pointer the previous frame's post processing type
+                   (uint8)
+    ll = pointer to the buffer (int)
+    mv_loc = flag indicating location of the motion compensated
+         (x,y) position with respect to the luminance MB (int);
+         0 -> inside MB, 1 -> outside MB
+    dx = horizontal component of the motion vector (int)
+    dy = vertical component of the motion vector (int)
+    mvwidth = number of blocks per row (int)
+    width = luminance VOP width in pixels (int)
+    height = luminance VOP height in pixels (int)
+
+ Local Stores/Buffers/Pointers Needed:
+    None
+
+ Global Stores/Buffers/Pointers Needed:
+    None
+
+ Outputs:
+    msk_deblock = flag that indicates whether deblocking is to be
+              performed (msk_deblock = 0) or not (msk_deblock =
+              1) (uint8)
+
+ Pointers and Buffers Modified:
+    pp_dec_y contents are the updated semapohore propagation data
+
+ Local Stores Modified:
+    None
+
+ Global Stores Modified:
+    None
+
+------------------------------------------------------------------------------
+ FUNCTION DESCRIPTION
+
+ This functions performs post processing semaphore propagation processing
+ after luminance prediction.
+
+*/
+
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include    "mp4dec_api.h"
+#include    "mp4def.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+#ifdef PV_POSTPROC_ON
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    /*----------------------------------------------------------------------------
+    ; FUNCTION CODE
+    ----------------------------------------------------------------------------*/
+    uint8 pp_semaphore_luma(
+        int xpred,      /* i */
+        int ypred,      /* i */
+        uint8   *pp_dec_y,  /* i/o */
+        uint8   *pstprcTypPrv,  /* i */
+        int *ll,        /* i */
+        int *mv_loc,    /* i/o */
+        int dx,     /* i */
+        int dy,     /* i */
+        int mvwidth,    /* i */
+        int width,      /* i */
+        int height      /* i */
+    )
+    {
+        /*----------------------------------------------------------------------------
+        ; Define all local variables
+        ----------------------------------------------------------------------------*/
+        int kk, mmvy, mmvx, nmvx, nmvy;
+        uint8   *pp_prev1, *pp_prev2, *pp_prev3, *pp_prev4;
+        uint8   msk_deblock = 0;        /*  11/3/00 */
+
+        /*----------------------------------------------------------------------------
+        ; Function body here
+        ----------------------------------------------------------------------------*/
+        /* Interframe Processing - 1 MV per MB */
+
+        /* check whether the MV points outside the frame */
+        if (xpred >= 0 && xpred <= ((width << 1) - (2*MB_SIZE)) && ypred >= 0 &&
+                ypred <= ((height << 1) - (2*MB_SIZE)))
+        {   /*****************************/
+            /* (x,y) is inside the frame */
+            /*****************************/
+
+            /*  10/24/2000 post_processing semaphore */
+            /* generation */
+
+            /*  10/23/2000 no boundary checking*/
+            *mv_loc = 0;
+
+            /* Calculate block x coordinate. Divide by 16 is for  */
+            /* converting half-pixel resolution to block          */
+            mmvx = xpred >> 4;
+
+            /* Calculate block y coordinate. Divide by 16 is for */
+            /* converting half-pixel resolution to block         */
+            mmvy = ypred >> 4;
+
+            /* Find post processing semaphore location for block */
+            /* used for prediction, i.e.,                */
+            /* pp_prev1 = &pstprcTypPrv[mmvy*mvwidth][mmvx]      */
+            pp_prev1 = pstprcTypPrv + mmvx + mmvy * mvwidth;
+
+            /* Check if MV is a multiple of 16 */
+            if ((dx&0xF) != 0)
+            {   /* dx is not a multiple of 16 */
+
+                /* pp_prev2 is the block to the right of */
+                /* pp_prev1 block            */
+                pp_prev2 = pp_prev1 + 1;
+
+                if ((dy&0xF) != 0)
+                {   /* dy is not a multiple of 16 */
+
+                    /* pp_prev3 is the block below */
+                    /* pp_prev1 block          */
+                    pp_prev3 = pp_prev1 + mvwidth;
+                }
+                else
+                {   /* dy is a multiple of 16 */
+
+                    pp_prev3 = pp_prev1;
+                }
+
+                /* pp_prev4 is the block to the right of */
+                /* pp_prev3 block.           */
+                pp_prev4 = pp_prev3 + 1;
+            }
+            else
+            {   /* dx is a multiple of 16 */
+
+                pp_prev2 = pp_prev1;
+
+                if ((dy&0xF) != 0)
+                {   /* dy is not a multiple of 16 */
+
+                    /* pp_prev3 is the block below */
+                    /* pp_prev1 block.         */
+                    pp_prev3 = pp_prev1 + mvwidth;
+                }
+                else
+                {   /* dy is a multiple of 16 */
+
+                    pp_prev3 = pp_prev1;
+                    msk_deblock = 0x3;
+                }
+
+                pp_prev4 = pp_prev3;
+            }
+
+            /* Perform post processing semaphore propagation for each */
+            /* of the 4 blocks in a MB.               */
+            for (kk = 0; kk < 4; kk++)
+            {
+                /* Deringing semaphore propagation */
+                if ((*(pp_dec_y) & 4) == 0)
+                {
+                    *(pp_dec_y) |= ((*(pp_prev1) | *(pp_prev2) |
+                                     *(pp_prev3) | *(pp_prev4)) & 0x4);
+                }
+                /* Deblocking semaphore propagation */
+                /*  11/3/00, change the propagation for deblocking */
+                if (msk_deblock == 0)
+                {
+                    *(pp_dec_y) = 0;
+                }
+
+                pp_dec_y += ll[kk];
+                pp_prev1 += ll[kk];
+                pp_prev2 += ll[kk];
+                pp_prev3 += ll[kk];
+                pp_prev4 += ll[kk];
+            }
+
+        }
+        else
+        {   /******************************/
+            /* (x,y) is outside the frame */
+            /******************************/
+
+            /*  10/24/2000 post_processing semaphore */
+            /* generation */
+
+            /*  10/23/2000 boundary checking*/
+            *mv_loc = 1;
+
+            /* Perform post processing semaphore propagation for each */
+            /* of the 4 blocks in a MB.               */
+            for (kk = 0; kk < 4; kk++)
+            {
+                /* Calculate block x coordinate and round (?).  */
+                /* Divide by 16 is for converting half-pixel    */
+                /* resolution to block.             */
+                mmvx = (xpred + ((kk & 1) << 3)) >> 4;
+                nmvx = mmvx;
+
+                /* Calculate block y coordinate and round (?).  */
+                /* Divide by 16 is for converting half-pixel    */
+                /* resolution to block.             */
+                mmvy = (ypred + ((kk & 2) << 2)) >> 4;
+                nmvy = mmvy;
+
+                /* Perform boundary checking */
+                if (nmvx < 0)
+                {
+                    nmvx = 0;
+                }
+                else if (nmvx > mvwidth - 1)
+                {
+                    nmvx = mvwidth - 1;
+                }
+
+                if (nmvy < 0)
+                {
+                    nmvy = 0;
+                }
+                else if (nmvy > (height >> 3) - 1)
+                {
+                    nmvy = (height >> 3) - 1;
+                }
+
+                /* Find post processing semaphore location for block */
+                /* used for prediction, i.e.,                */
+                /* pp_prev1 = &pstprcTypPrv[nmvy*mvwidth][nmvx]      */
+                pp_prev1 = pstprcTypPrv + nmvx + nmvy * mvwidth;
+
+                /* Check if x component of MV is a multiple of 16    */
+                /* and check if block x coordinate is out of bounds  */
+                if (((dx&0xF) != 0) && (mmvx + 1 < mvwidth - 1))
+                {   /* dx is not a multiple of 16 and the block */
+                    /* x coordinate is within the bounds        */
+
+                    /* pp_prev2 is the block to the right of */
+                    /* pp_prev1 block            */
+                    pp_prev2 = pp_prev1 + 1;
+
+                    /* Check if y component of MV is a multiple */
+                    /* of 16 and check if block y coordinate is */
+                    /* out of bounds                */
+                    if (((dy&0xF) != 0) && (mmvy + 1 < (height >> 3) - 1))
+                    {   /* dy is not a multiple of 16 and */
+                        /* the block y coordinate is      */
+                        /* within the bounds              */
+
+                        /* pp_prev3 is the block below */
+                        /* pp_prev1 block          */
+                        pp_prev3 = pp_prev1 + mvwidth;
+
+                        /* all prediction are from different blocks */
+                        msk_deblock = 0x3;
+                    }
+                    else
+                    {   /* dy is a multiple of 16 or the block */
+                        /* y coordinate is out of bounds       */
+
+                        pp_prev3 = pp_prev1;
+                    }
+
+                    /* pp_prev4 is the block to the right of */
+                    /* pp_prev3 block.           */
+                    pp_prev4 = pp_prev3 + 1;
+                }
+                else
+                {   /* dx is a multiple of 16 or the block x */
+                    /* coordinate is out of bounds           */
+
+                    pp_prev2 = pp_prev1;
+
+                    /* Check if y component of MV is a multiple */
+                    /* of 16 and check if block y coordinate is */
+                    /* out of bounds                */
+                    if (((dy&0xF) != 0) && (mmvy + 1 < (height >> 3) - 1))
+                    {   /* dy is not a multiple of 16 and */
+                        /* the block y coordinate is      */
+                        /* within the bounds              */
+
+                        /* pp_prev3 is the block below */
+                        /* pp_prev1 block.         */
+                        pp_prev3 = pp_prev1 + mvwidth;
+                    }
+                    else
+                    {   /* dy is a multiple of 16 or the block */
+                        /* y coordinate is out of bounds       */
+
+                        pp_prev3 = pp_prev1;
+                    }
+
+                    pp_prev4 = pp_prev3;
+                }
+
+                /* Deringing semaphore propagation */
+                if ((*(pp_dec_y)&4) == 0)
+                {
+                    *(pp_dec_y) |= ((*(pp_prev1) |
+                                     *(pp_prev2) | *(pp_prev3) |
+                                     *(pp_prev4)) & 0x4);
+                }
+                /* Deblocking semaphore propagation */
+                /*  11/3/00, change the propaga= */
+                /* tion for deblocking */
+                if (msk_deblock == 0)
+                {
+                    *(pp_dec_y) = 0;
+                }
+
+                pp_dec_y += ll[kk];
+            }
+        }
+
+        /*----------------------------------------------------------------------------
+        ; Return nothing or data or data pointer
+        ----------------------------------------------------------------------------*/
+        return (msk_deblock);
+    }
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/pvdec_api.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/pvdec_api.cpp
new file mode 100644
index 0000000..0c354d9
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/pvdec_api.cpp
@@ -0,0 +1,1696 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h"
+#include "vlc_decode.h"
+#include "bitstream.h"
+
+#define OSCL_DISABLE_WARNING_CONDITIONAL_IS_CONSTANT
+
+#ifdef DEC_INTERNAL_MEMORY_OPT
+#define QCIF_MBS 99
+#define QCIF_BS (4*QCIF_MBS)
+#define QCIF_MB_ROWS 11
+extern uint8                IMEM_sliceNo[QCIF_MBS];
+extern uint8                IMEM_acPredFlag[QCIF_MBS];
+extern uint8                IMEM_headerInfo_Mode[QCIF_MBS];
+extern uint8                IMEM_headerInfo_CBP[QCIF_MBS];
+extern int                  IMEM_headerInfo_QPMB[QCIF_MBS];
+extern MacroBlock           IMEM_mblock;
+extern MOT                  IMEM_motX[QCIF_BS];
+extern MOT                  IMEM_motY[QCIF_BS];
+extern BitstreamDecVideo    IMEM_BitstreamDecVideo[4];
+extern typeDCStore          IMEM_predDC[QCIF_MBS];
+extern typeDCACStore        IMEM_predDCAC_col[QCIF_MB_ROWS+1];
+
+extern VideoDecData         IMEM_VideoDecData[1];
+extern Vop                  IMEM_currVop[1];
+extern Vop                  IMEM_prevVop[1];
+extern PIXEL                IMEM_currVop_yChan[QCIF_MBS*128*3];
+extern PIXEL                IMEM_prevVop_yChan[QCIF_MBS*128*3];
+extern uint8                IMEM_pstprcTypCur[6*QCIF_MBS];
+extern uint8                IMEM_pstprcTypPrv[6*QCIF_MBS];
+
+
+extern Vop                  IMEM_vopHEADER[2];
+extern Vol                  IMEM_VOL[2];
+extern Vop                  IMEM_vopHeader[2][1];
+extern Vol                  IMEM_vol[2][1];
+
+#endif
+
+/* ======================================================================== */
+/*  Function : PVInitVideoDecoder()                                         */
+/*  Date     : 04/11/2000, 08/29/2000                                       */
+/*  Purpose  : Initialization of the MPEG-4 video decoder library.          */
+/*             The return type is Bool instead of PV_STATUS because         */
+/*             we don't want to expose PV_STATUS to (outside) programmers   */
+/*             that use our decoder library SDK.                            */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool PVInitVideoDecoder(VideoDecControls *decCtrl, uint8 *volbuf[],
+                                        int32 *volbuf_size, int nLayers, int width, int height, MP4DecodingMode mode)
+{
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+    Bool status = PV_TRUE;
+    int idx;
+    BitstreamDecVideo *stream;
+
+
+    oscl_memset(decCtrl, 0, sizeof(VideoDecControls)); /* fix a size bug.   03/28/2001 */
+    decCtrl->nLayers = nLayers;
+    for (idx = 0; idx < nLayers; idx++)
+    {
+        decCtrl->volbuf[idx] = volbuf[idx];
+        decCtrl->volbuf_size[idx] = volbuf_size[idx];
+    }
+
+    /* memory allocation & initialization */
+#ifdef DEC_INTERNAL_MEMORY_OPT
+    video = IMEM_VideoDecData;
+#else
+    video = (VideoDecData *) oscl_malloc(sizeof(VideoDecData));
+#endif
+    if (video != NULL)
+    {
+        oscl_memset(video, 0, sizeof(VideoDecData));
+        video->memoryUsage = sizeof(VideoDecData);
+        video->numberOfLayers = nLayers;
+#ifdef DEC_INTERNAL_MEMORY_OPT
+        video->vol = (Vol **) IMEM_VOL;
+#else
+        video->vol = (Vol **) oscl_malloc(nLayers * sizeof(Vol *));
+#endif
+        if (video->vol == NULL) status = PV_FALSE;
+        video->memoryUsage += nLayers * sizeof(Vol *);
+
+
+        /* we need to setup this pointer for the application to */
+        /*    pass it around.                                   */
+        decCtrl->videoDecoderData = (void *) video;
+        video->videoDecControls = decCtrl;  /* yes. we have a cyclic */
+        /* references here :)    */
+
+        /* Allocating Vop space, this has to change when we add */
+        /*    spatial scalability to the decoder                */
+#ifdef DEC_INTERNAL_MEMORY_OPT
+        video->currVop = IMEM_currVop;
+        if (video->currVop == NULL) status = PV_FALSE;
+        else oscl_memset(video->currVop, 0, sizeof(Vop));
+        video->prevVop = IMEM_prevVop;
+        if (video->prevVop == NULL) status = PV_FALSE;
+        else oscl_memset(video->prevVop, 0, sizeof(Vop));
+        video->memoryUsage += (sizeof(Vop) * 2);
+        video->vopHeader = (Vop **) IMEM_vopHEADER;
+#else
+
+        video->currVop = (Vop *) oscl_malloc(sizeof(Vop));
+        if (video->currVop == NULL) status = PV_FALSE;
+        else oscl_memset(video->currVop, 0, sizeof(Vop));
+        video->prevVop = (Vop *) oscl_malloc(sizeof(Vop));
+        if (video->prevVop == NULL) status = PV_FALSE;
+        else oscl_memset(video->prevVop, 0, sizeof(Vop));
+        video->memoryUsage += (sizeof(Vop) * 2);
+
+        video->vopHeader = (Vop **) oscl_malloc(sizeof(Vop *) * nLayers);
+#endif
+        if (video->vopHeader == NULL) status = PV_FALSE;
+        else oscl_memset(video->vopHeader, 0, sizeof(Vop *)*nLayers);
+        video->memoryUsage += (sizeof(Vop *) * nLayers);
+
+        video->initialized = PV_FALSE;
+        /* Decode the header to get all information to allocate data */
+        if (status == PV_TRUE)
+        {
+            /* initialize decoded frame counter.   04/24/2001 */
+            video->frame_idx = -1;
+
+
+            for (idx = 0; idx < nLayers; idx++)
+            {
+
+#ifdef DEC_INTERNAL_MEMORY_OPT
+                video->vopHeader[idx] = IMEM_vopHeader[idx];
+#else
+                video->vopHeader[idx] = (Vop *) oscl_malloc(sizeof(Vop));
+#endif
+                if (video->vopHeader[idx] == NULL)
+                {
+                    status = PV_FALSE;
+                    break;
+                }
+                else
+                {
+                    oscl_memset(video->vopHeader[idx], 0, sizeof(Vop));
+                    video->vopHeader[idx]->timeStamp = 0;
+                    video->memoryUsage += (sizeof(Vop));
+                }
+#ifdef DEC_INTERNAL_MEMORY_OPT
+                video->vol[idx] = IMEM_vol[idx];
+                video->memoryUsage += sizeof(Vol);
+                oscl_memset(video->vol[idx], 0, sizeof(Vol));
+                if (video->vol[idx] == NULL) status = PV_FALSE;
+                stream = IMEM_BitstreamDecVideo;
+#else
+                video->vol[idx] = (Vol *) oscl_malloc(sizeof(Vol));
+                if (video->vol[idx] == NULL)
+                {
+                    status = PV_FALSE;
+                    break;
+                }
+                else
+                {
+                    video->memoryUsage += sizeof(Vol);
+                    oscl_memset(video->vol[idx], 0, sizeof(Vol));
+                }
+
+                stream = (BitstreamDecVideo *) oscl_malloc(sizeof(BitstreamDecVideo));
+#endif
+                video->memoryUsage += sizeof(BitstreamDecVideo);
+                if (stream == NULL)
+                {
+                    status = PV_FALSE;
+                    break;
+                }
+                else
+                {
+                    int32 buffer_size;
+                    if ((buffer_size = BitstreamOpen(stream, idx)) < 0)
+                    {
+                        mp4dec_log("InitVideoDecoder(): Can't allocate bitstream buffer.\n");
+                        status = PV_FALSE;
+                        break;
+                    }
+                    video->memoryUsage += buffer_size;
+                    video->vol[idx]->bitstream = stream;
+                    video->vol[idx]->volID = idx;
+                    video->vol[idx]->timeInc_offset = 0;  /*  11/12/01 */
+                    video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader;
+                    video->vlcDecCoeffInter = &VlcDecTCOEFShortHeader;
+                    if (mode == MPEG4_MODE)
+                    {
+                        /* Set up VOL header bitstream for frame-based decoding.  08/30/2000 */
+                        BitstreamReset(stream, decCtrl->volbuf[idx], decCtrl->volbuf_size[idx]);
+
+                        switch (DecodeVOLHeader(video, idx))
+                        {
+                            case PV_SUCCESS :
+                                if (status == PV_TRUE)
+                                    status = PV_TRUE;   /*  we want to make sure that if first layer is bad, second layer is good return PV_FAIL */
+                                else
+                                    status = PV_FALSE;
+                                break;
+#ifdef PV_TOLERATE_VOL_ERRORS
+                            case PV_BAD_VOLHEADER:
+                                status = PV_TRUE;
+                                break;
+#endif
+                            default :
+                                status = PV_FALSE;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        video->shortVideoHeader = PV_TRUE;
+                    }
+
+                    if (video->shortVideoHeader == PV_TRUE)
+                    {
+                        mode = H263_MODE;
+                        /* Set max width and height.  In H.263 mode, we use    */
+                        /*  volbuf_size[0] to pass in width and volbuf_size[1] */
+                        /*  to pass in height.                    04/23/2001 */
+                        video->prevVop->temporalRef = 0; /*  11/12/01 */
+                        /* Compute some convenience variables:   04/23/2001 */
+                        video->vol[idx]->quantType = 0;
+                        video->vol[idx]->quantPrecision = 5;
+                        video->vol[idx]->errorResDisable = 1;
+                        video->vol[idx]->dataPartitioning = 0;
+                        video->vol[idx]->useReverseVLC = 0;
+                        video->intra_acdcPredDisable = 1;
+                        video->vol[idx]->scalability = 0;
+                        video->size = (int32)width * height;
+
+                        video->displayWidth = video->width = width;
+                        video->displayHeight = video->height = height;
+#ifdef PV_ANNEX_IJKT_SUPPORT
+                        video->modified_quant = 0;
+                        video->advanced_INTRA = 0;
+                        video->deblocking = 0;
+                        video->slice_structure = 0;
+#endif
+                    }
+
+                }
+            }
+
+        }
+        if (status != PV_FALSE)
+        {
+            status = PVAllocVideoData(decCtrl, width, height, nLayers);
+            video->initialized = PV_TRUE;
+        }
+    }
+    else
+    {
+        status = PV_FALSE;
+    }
+
+    if (status == PV_FALSE) PVCleanUpVideoDecoder(decCtrl);
+
+    return status;
+}
+
+Bool PVAllocVideoData(VideoDecControls *decCtrl, int width, int height, int nLayers)
+{
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+    Bool status = PV_TRUE;
+    int nTotalMB;
+    int nMBPerRow;
+    int32 size;
+
+    if (video->shortVideoHeader == PV_TRUE)
+    {
+        video->displayWidth = video->width = width;
+        video->displayHeight = video->height = height;
+
+        video->nMBPerRow =
+            video->nMBinGOB  = video->width / MB_SIZE;
+        video->nMBPerCol =
+            video->nGOBinVop = video->height / MB_SIZE;
+        video->nTotalMB =
+            video->nMBPerRow * video->nMBPerCol;
+    }
+
+    size = (int32)sizeof(PIXEL) * video->width * video->height;
+#ifdef PV_MEMORY_POOL
+    decCtrl->size = size;
+#else
+#ifdef DEC_INTERNAL_MEMORY_OPT
+    video->currVop->yChan = IMEM_currVop_yChan; /* Allocate memory for all VOP OKA 3/2/1*/
+    if (video->currVop->yChan == NULL) status = PV_FALSE;
+    video->currVop->uChan = video->currVop->yChan + size;
+    video->currVop->vChan = video->currVop->uChan + (size >> 2);
+
+    video->prevVop->yChan = IMEM_prevVop_yChan; /* Allocate memory for all VOP OKA 3/2/1*/
+    if (video->prevVop->yChan == NULL) status = PV_FALSE;
+    video->prevVop->uChan = video->prevVop->yChan + size;
+    video->prevVop->vChan = video->prevVop->uChan + (size >> 2);
+#else
+    video->currVop->yChan = (PIXEL *) oscl_malloc(size * 3 / 2); /* Allocate memory for all VOP OKA 3/2/1*/
+    if (video->currVop->yChan == NULL) status = PV_FALSE;
+
+    video->currVop->uChan = video->currVop->yChan + size;
+    video->currVop->vChan = video->currVop->uChan + (size >> 2);
+    video->prevVop->yChan = (PIXEL *) oscl_malloc(size * 3 / 2); /* Allocate memory for all VOP OKA 3/2/1*/
+    if (video->prevVop->yChan == NULL) status = PV_FALSE;
+
+    video->prevVop->uChan = video->prevVop->yChan + size;
+    video->prevVop->vChan = video->prevVop->uChan + (size >> 2);
+#endif
+    video->memoryUsage += (size * 3);
+#endif   // MEMORY_POOL
+    /* Note that baseVop, enhcVop is only used to hold enhancement */
+    /*    layer header information.                  05/04/2000  */
+    if (nLayers > 1)
+    {
+        video->prevEnhcVop = (Vop *) oscl_malloc(sizeof(Vop));
+        video->memoryUsage += (sizeof(Vop));
+        if (video->prevEnhcVop == NULL)
+        {
+            status = PV_FALSE;
+        }
+        else
+        {
+            oscl_memset(video->prevEnhcVop, 0, sizeof(Vop));
+#ifndef PV_MEMORY_POOL
+            video->prevEnhcVop->yChan = (PIXEL *) oscl_malloc(size * 3 / 2); /* Allocate memory for all VOP OKA 3/2/1*/
+            if (video->prevEnhcVop->yChan == NULL) status = PV_FALSE;
+            video->prevEnhcVop->uChan = video->prevEnhcVop->yChan + size;
+            video->prevEnhcVop->vChan = video->prevEnhcVop->uChan + (size >> 2);
+            video->memoryUsage += (3 * size / 2);
+#endif
+        }
+    }
+
+    /* Allocating space for slices, AC prediction flag, and */
+    /*    AC/DC prediction storage */
+    nTotalMB = video->nTotalMB;
+    nMBPerRow = video->nMBPerRow;
+
+#ifdef DEC_INTERNAL_MEMORY_OPT
+    video->sliceNo = (uint8 *)(IMEM_sliceNo);
+    if (video->sliceNo == NULL) status = PV_FALSE;
+    video->memoryUsage += nTotalMB;
+    video->acPredFlag = (uint8 *)(IMEM_acPredFlag);
+    if (video->acPredFlag == NULL) status = PV_FALSE;
+    video->memoryUsage += (nTotalMB);
+    video->predDC = (typeDCStore *)(IMEM_predDC);
+    if (video->predDC == NULL) status = PV_FALSE;
+    video->memoryUsage += (nTotalMB * sizeof(typeDCStore));
+    video->predDCAC_col = (typeDCACStore *)(IMEM_predDCAC_col);
+    if (video->predDCAC_col == NULL) status = PV_FALSE;
+    video->memoryUsage += ((nMBPerRow + 1) * sizeof(typeDCACStore));
+    video->predDCAC_row = video->predDCAC_col + 1;
+    video->headerInfo.Mode = (uint8 *)(IMEM_headerInfo_Mode);
+    if (video->headerInfo.Mode == NULL) status = PV_FALSE;
+    video->memoryUsage += nTotalMB;
+    video->headerInfo.CBP = (uint8 *)(IMEM_headerInfo_CBP);
+    if (video->headerInfo.CBP == NULL) status = PV_FALSE;
+    video->memoryUsage += nTotalMB;
+    video->QPMB = (int *)(IMEM_headerInfo_QPMB);
+    if (video->QPMB == NULL) status = PV_FALSE;
+    video->memoryUsage += (nTotalMB * sizeof(int));
+    video->mblock = &IMEM_mblock;
+    if (video->mblock == NULL) status = PV_FALSE;
+    oscl_memset(video->mblock->block, 0, sizeof(int16)*6*NCOEFF_BLOCK); //  Aug 23,2005
+
+    video->memoryUsage += sizeof(MacroBlock);
+    video->motX = (MOT *)(IMEM_motX);
+    if (video->motX == NULL) status = PV_FALSE;
+    video->motY = (MOT *)(IMEM_motY);
+    if (video->motY == NULL) status = PV_FALSE;
+    video->memoryUsage += (sizeof(MOT) * 8 * nTotalMB);
+#else
+    video->sliceNo = (uint8 *) oscl_malloc(nTotalMB);
+    if (video->sliceNo == NULL) status = PV_FALSE;
+    video->memoryUsage += nTotalMB;
+
+    video->acPredFlag = (uint8 *) oscl_malloc(nTotalMB * sizeof(uint8));
+    if (video->acPredFlag == NULL) status = PV_FALSE;
+    video->memoryUsage += (nTotalMB);
+
+    video->predDC = (typeDCStore *) oscl_malloc(nTotalMB * sizeof(typeDCStore));
+    if (video->predDC == NULL) status = PV_FALSE;
+    video->memoryUsage += (nTotalMB * sizeof(typeDCStore));
+
+    video->predDCAC_col = (typeDCACStore *) oscl_malloc((nMBPerRow + 1) * sizeof(typeDCACStore));
+    if (video->predDCAC_col == NULL) status = PV_FALSE;
+    video->memoryUsage += ((nMBPerRow + 1) * sizeof(typeDCACStore));
+
+    /* element zero will be used for storing vertical (col) AC coefficients */
+    /*  the rest will be used for storing horizontal (row) AC coefficients  */
+    video->predDCAC_row = video->predDCAC_col + 1;        /*  ACDC */
+
+    /* Allocating HeaderInfo structure & Quantizer array */
+    video->headerInfo.Mode = (uint8 *) oscl_malloc(nTotalMB);
+    if (video->headerInfo.Mode == NULL) status = PV_FALSE;
+    video->memoryUsage += nTotalMB;
+    video->headerInfo.CBP = (uint8 *) oscl_malloc(nTotalMB);
+    if (video->headerInfo.CBP == NULL) status = PV_FALSE;
+    video->memoryUsage += nTotalMB;
+    video->QPMB = (int16 *) oscl_malloc(nTotalMB * sizeof(int16));
+    if (video->QPMB == NULL) status = PV_FALSE;
+    video->memoryUsage += (nTotalMB * sizeof(int));
+
+    /* Allocating macroblock space */
+    video->mblock = (MacroBlock *) oscl_malloc(sizeof(MacroBlock));
+    if (video->mblock == NULL)
+    {
+        status = PV_FALSE;
+    }
+    else
+    {
+        oscl_memset(video->mblock->block, 0, sizeof(int16)*6*NCOEFF_BLOCK); //  Aug 23,2005
+
+        video->memoryUsage += sizeof(MacroBlock);
+    }
+    /* Allocating motion vector space */
+    video->motX = (MOT *) oscl_malloc(sizeof(MOT) * 4 * nTotalMB);
+    if (video->motX == NULL) status = PV_FALSE;
+    video->motY = (MOT *) oscl_malloc(sizeof(MOT) * 4 * nTotalMB);
+    if (video->motY == NULL) status = PV_FALSE;
+    video->memoryUsage += (sizeof(MOT) * 8 * nTotalMB);
+#endif
+
+#ifdef PV_POSTPROC_ON
+    /* Allocating space for post-processing Mode */
+#ifdef DEC_INTERNAL_MEMORY_OPT
+    video->pstprcTypCur = IMEM_pstprcTypCur;
+    video->memoryUsage += (nTotalMB * 6);
+    if (video->pstprcTypCur == NULL)
+    {
+        status = PV_FALSE;
+    }
+    else
+    {
+        oscl_memset(video->pstprcTypCur, 0, 4*nTotalMB + 2*nTotalMB);
+    }
+
+    video->pstprcTypPrv = IMEM_pstprcTypPrv;
+    video->memoryUsage += (nTotalMB * 6);
+    if (video->pstprcTypPrv == NULL)
+    {
+        status = PV_FALSE;
+    }
+    else
+    {
+        oscl_memset(video->pstprcTypPrv, 0, nTotalMB*6);
+    }
+
+#else
+    video->pstprcTypCur = (uint8 *) oscl_malloc(nTotalMB * 6);
+    video->memoryUsage += (nTotalMB * 6);
+    if (video->pstprcTypCur == NULL)
+    {
+        status = PV_FALSE;
+    }
+    else
+    {
+        oscl_memset(video->pstprcTypCur, 0, 4*nTotalMB + 2*nTotalMB);
+    }
+
+    video->pstprcTypPrv = (uint8 *) oscl_malloc(nTotalMB * 6);
+    video->memoryUsage += (nTotalMB * 6);
+    if (video->pstprcTypPrv == NULL)
+    {
+        status = PV_FALSE;
+    }
+    else
+    {
+        oscl_memset(video->pstprcTypPrv, 0, nTotalMB*6);
+    }
+
+#endif
+
+#endif
+
+    /* initialize the decoder library */
+    video->prevVop->predictionType = I_VOP;
+    video->prevVop->timeStamp = 0;
+#ifndef PV_MEMORY_POOL
+    oscl_memset(video->prevVop->yChan, 16, sizeof(uint8)*size);     /*  10/31/01 */
+    oscl_memset(video->prevVop->uChan, 128, sizeof(uint8)*size / 2);
+
+    oscl_memset(video->currVop->yChan, 0, sizeof(uint8)*size*3 / 2);
+    if (nLayers > 1)
+    {
+        oscl_memset(video->prevEnhcVop->yChan, 0, sizeof(uint8)*size*3 / 2);
+        video->prevEnhcVop->timeStamp = 0;
+    }
+    video->concealFrame = video->prevVop->yChan;               /*  07/07/2001 */
+    decCtrl->outputFrame = video->prevVop->yChan;              /*  06/19/2002 */
+#endif
+
+    /* always start from base layer */
+    video->currLayer = 0;
+    return status;
+}
+
+/* ======================================================================== */
+/*  Function : PVResetVideoDecoder()                                        */
+/*  Date     : 01/14/2002                                                   */
+/*  Purpose  : Reset video timestamps                                       */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Bool PVResetVideoDecoder(VideoDecControls *decCtrl)
+{
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+    int idx;
+
+    for (idx = 0; idx < decCtrl->nLayers; idx++)
+    {
+        video->vopHeader[idx]->timeStamp = 0;
+    }
+    video->prevVop->timeStamp = 0;
+    if (decCtrl->nLayers > 1)
+        video->prevEnhcVop->timeStamp = 0;
+
+    oscl_memset(video->mblock->block, 0, sizeof(int16)*6*NCOEFF_BLOCK); //  Aug 23,2005
+
+    return PV_TRUE;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVCleanUpVideoDecoder()                                      */
+/*  Date     : 04/11/2000, 08/29/2000                                       */
+/*  Purpose  : Cleanup of the MPEG-4 video decoder library.                 */
+/*  In/out   :                                                              */
+/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
+/*  Modified :                                                              */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool PVCleanUpVideoDecoder(VideoDecControls *decCtrl)
+{
+    int idx;
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+#ifdef DEC_INTERNAL_MEMORY_OPT
+    if (video)
+    {
+#ifdef PV_POSTPROC_ON
+        video->pstprcTypCur = NULL;
+        video->pstprcTypPrv = NULL;
+#endif
+
+        video->acPredFlag       = NULL;
+        video->sliceNo          = NULL;
+        video->motX             = NULL;
+        video->motY             = NULL;
+        video->mblock           = NULL;
+        video->QPMB             = NULL;
+        video->predDC           = NULL;
+        video->predDCAC_row     = NULL;
+        video->predDCAC_col     = NULL;
+        video->headerInfo.Mode  = NULL;
+        video->headerInfo.CBP   = NULL;
+        if (video->numberOfLayers > 1)
+        {
+            if (video->prevEnhcVop)
+            {
+                video->prevEnhcVop->uChan = NULL;
+                video->prevEnhcVop->vChan = NULL;
+                if (video->prevEnhcVop->yChan) oscl_free(video->prevEnhcVop->yChan);
+                oscl_free(video->prevEnhcVop);
+            }
+        }
+        if (video->currVop)
+        {
+            video->currVop->uChan = NULL;
+            video->currVop->vChan = NULL;
+            if (video->currVop->yChan)
+                video->currVop->yChan = NULL;
+            video->currVop = NULL;
+        }
+        if (video->prevVop)
+        {
+            video->prevVop->uChan = NULL;
+            video->prevVop->vChan = NULL;
+            if (video->prevVop->yChan)
+                video->prevVop->yChan = NULL;
+            video->prevVop = NULL;
+        }
+
+        if (video->vol)
+        {
+            for (idx = 0; idx < video->numberOfLayers; idx++)
+            {
+                if (video->vol[idx])
+                {
+                    BitstreamClose(video->vol[idx]->bitstream);
+                    video->vol[idx]->bitstream = NULL;
+                    video->vol[idx] = NULL;
+                }
+                video->vopHeader[idx] = NULL;
+
+            }
+            video->vol = NULL;
+            video->vopHeader = NULL;
+        }
+
+        video = NULL;
+        decCtrl->videoDecoderData = NULL;
+    }
+
+#else
+
+    if (video)
+    {
+#ifdef PV_POSTPROC_ON
+        if (video->pstprcTypCur) oscl_free(video->pstprcTypCur);
+        if (video->pstprcTypPrv) oscl_free(video->pstprcTypPrv);
+#endif
+        if (video->predDC) oscl_free(video->predDC);
+        video->predDCAC_row = NULL;
+        if (video->predDCAC_col) oscl_free(video->predDCAC_col);
+        if (video->motX) oscl_free(video->motX);
+        if (video->motY) oscl_free(video->motY);
+        if (video->mblock) oscl_free(video->mblock);
+        if (video->QPMB) oscl_free(video->QPMB);
+        if (video->headerInfo.Mode) oscl_free(video->headerInfo.Mode);
+        if (video->headerInfo.CBP) oscl_free(video->headerInfo.CBP);
+        if (video->sliceNo) oscl_free(video->sliceNo);
+        if (video->acPredFlag) oscl_free(video->acPredFlag);
+
+        if (video->numberOfLayers > 1)
+        {
+            if (video->prevEnhcVop)
+            {
+                video->prevEnhcVop->uChan = NULL;
+                video->prevEnhcVop->vChan = NULL;
+                if (video->prevEnhcVop->yChan) oscl_free(video->prevEnhcVop->yChan);
+                oscl_free(video->prevEnhcVop);
+            }
+        }
+        if (video->currVop)
+        {
+
+#ifndef PV_MEMORY_POOL
+            video->currVop->uChan = NULL;
+            video->currVop->vChan = NULL;
+            if (video->currVop->yChan)
+                oscl_free(video->currVop->yChan);
+#endif
+            oscl_free(video->currVop);
+        }
+        if (video->prevVop)
+        {
+#ifndef PV_MEMORY_POOL
+            video->prevVop->uChan = NULL;
+            video->prevVop->vChan = NULL;
+            if (video->prevVop->yChan)
+                oscl_free(video->prevVop->yChan);
+#endif
+            oscl_free(video->prevVop);
+        }
+
+        if (video->vol)
+        {
+            for (idx = 0; idx < video->numberOfLayers; idx++)
+            {
+                if (video->vol[idx])
+                {
+                    if (video->vol[idx]->bitstream)
+                    {
+                        BitstreamClose(video->vol[idx]->bitstream);
+                        oscl_free(video->vol[idx]->bitstream);
+                    }
+                    oscl_free(video->vol[idx]);
+                }
+
+            }
+            oscl_free(video->vol);
+        }
+
+        for (idx = 0; idx < video->numberOfLayers; idx++)
+        {
+            if (video->vopHeader[idx]) oscl_free(video->vopHeader[idx]);
+        }
+
+        if (video->vopHeader) oscl_free(video->vopHeader);
+
+        oscl_free(video);
+        decCtrl->videoDecoderData = NULL;
+    }
+#endif
+    return PV_TRUE;
+}
+/* ======================================================================== */
+/*  Function : PVGetVideoDimensions()                                       */
+/*  Date     : 040505                                                       */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : the display_width and display_height of                      */
+/*          the frame in the current layer.                                 */
+/*  Note     : This is not a macro or inline function because we do         */
+/*              not want to expose our internal data structure.             */
+/*  Modified :                                                              */
+/* ======================================================================== */
+OSCL_EXPORT_REF void PVGetVideoDimensions(VideoDecControls *decCtrl, int32 *display_width, int32 *display_height)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    *display_width = video->displayWidth;
+    *display_height = video->displayHeight;
+}
+
+/* ======================================================================== */
+/*  Function : PVGetVideoTimeStamp()                                        */
+/*  Date     : 04/27/2000, 08/29/2000                                       */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : current time stamp in millisecond.                           */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+uint32 PVGetVideoTimeStamp(VideoDecControls *decCtrl)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    return video->currTimestamp;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVSetPostProcType()                                          */
+/*  Date     : 07/07/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : Set post-processing filter type.                             */
+/*  Note     :                                                              */
+/*  Modified : . 08/29/2000 changes the name for consistency.               */
+/* ======================================================================== */
+OSCL_EXPORT_REF void PVSetPostProcType(VideoDecControls *decCtrl, int mode)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    video->postFilterType = mode;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVGetDecBitrate()                                            */
+/*  Date     : 08/23/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : This function returns the average bits per second.           */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+int PVGetDecBitrate(VideoDecControls *decCtrl)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    int     idx;
+    int32   sum = 0;
+
+    for (idx = 0; idx < BITRATE_AVERAGE_WINDOW; idx++)
+    {
+        sum += video->nBitsPerVop[idx];
+    }
+    sum = (sum * video->frameRate) / (10 * BITRATE_AVERAGE_WINDOW);
+    return (int) sum;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVGetDecFramerate()                                          */
+/*  Date     : 08/23/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : This function returns the average frame per 10 second.       */
+/*  Note     : The fps can be calculated by PVGetDecFramerate()/10          */
+/*  Modified :                                                              */
+/* ======================================================================== */
+int PVGetDecFramerate(VideoDecControls *decCtrl)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+
+    return video->frameRate;
+}
+
+/* ======================================================================== */
+/*  Function : PVGetOutputFrame()                                           */
+/*  Date     : 05/07/2001                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : This function returns the pointer to the output frame        */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+uint8 *PVGetDecOutputFrame(VideoDecControls *decCtrl)
+{
+    return decCtrl->outputFrame;
+}
+
+/* ======================================================================== */
+/*  Function : PVGetLayerID()                                               */
+/*  Date     : 07/09/2001                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : This function returns decoded frame layer id (BASE/ENHANCE)  */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+int PVGetLayerID(VideoDecControls *decCtrl)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    return video->currLayer;
+}
+/* ======================================================================== */
+/*  Function : PVGetDecMemoryUsage()                                        */
+/*  Date     : 08/23/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : This function returns the amount of memory used.             */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+int32 PVGetDecMemoryUsage(VideoDecControls *decCtrl)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    return video->memoryUsage;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVGetDecBitstreamMode()                                      */
+/*  Date     : 08/23/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : This function returns the decoding mode of the baselayer     */
+/*              bitstream.                                                  */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+OSCL_EXPORT_REF MP4DecodingMode PVGetDecBitstreamMode(VideoDecControls *decCtrl)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    if (video->shortVideoHeader)
+    {
+        return H263_MODE;
+    }
+    else
+    {
+        return MPEG4_MODE;
+    }
+}
+
+
+/* ======================================================================== */
+/*  Function : PVExtractVolHeader()                                         */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : Extract vol header of the bitstream from buffer[].           */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Bool PVExtractVolHeader(uint8 *video_buffer, uint8 *vol_header, int32 *vol_header_size)
+{
+    int idx = -1;
+    uint8 start_code_prefix[] = { 0x00, 0x00, 0x01 };
+    uint8 h263_prefix[] = { 0x00, 0x00, 0x80 };
+
+    if (oscl_memcmp(h263_prefix, video_buffer, 3) == 0) /* we have short header stream */
+    {
+        oscl_memcpy(vol_header, video_buffer, 32);
+        *vol_header_size = 32;
+        return TRUE;
+    }
+    else
+    {
+        if (oscl_memcmp(start_code_prefix, video_buffer, 3) ||
+                (video_buffer[3] != 0xb0 && video_buffer[3] >= 0x20)) return FALSE;
+
+        do
+        {
+            idx++;
+            while (oscl_memcmp(start_code_prefix, video_buffer + idx, 3))
+            {
+                idx++;
+                if (idx + 3 >= *vol_header_size) goto quit;
+            }
+        }
+        while (video_buffer[idx+3] != 0xb3 && video_buffer[idx+3] != 0xb6);
+
+        oscl_memcpy(vol_header, video_buffer, idx);
+        *vol_header_size = idx;
+        return TRUE;
+    }
+
+quit:
+    oscl_memcpy(vol_header, video_buffer, *vol_header_size);
+    return FALSE;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVLocateFrameHeader()                                        */
+/*  Date     : 04/8/2005                                                    */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : Return the offset to the first SC in the buffer              */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+int32 PVLocateFrameHeader(uint8 *ptr, int32 size)
+{
+    int count = 0;
+    int32 i = size;
+
+    if (size < 1)
+    {
+        return 0;
+    }
+    while (i--)
+    {
+        if ((count > 1) && (*ptr == 0x01))
+        {
+            i += 2;
+            break;
+        }
+
+        if (*ptr++)
+            count = 0;
+        else
+            count++;
+    }
+    return (size - (i + 1));
+}
+
+
+/* ======================================================================== */
+/*  Function : PVLocateH263FrameHeader()                                    */
+/*  Date     : 04/8/2005                                                    */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : Return the offset to the first SC in the buffer              */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+int32 PVLocateH263FrameHeader(uint8 *ptr, int32 size)
+{
+    int count = 0;
+    int32 i = size;
+
+    if (size < 1)
+    {
+        return 0;
+    }
+
+    while (i--)
+    {
+        if ((count > 1) && ((*ptr & 0xFC) == 0x80))
+        {
+            i += 2;
+            break;
+        }
+
+        if (*ptr++)
+            count = 0;
+        else
+            count++;
+    }
+    return (size - (i + 1));
+}
+
+
+/* ======================================================================== */
+/*  Function : PVDecodeVideoFrame()                                         */
+/*  Date     : 08/29/2000                                                   */
+/*  Purpose  : Decode one video frame and return a YUV-12 image.            */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Note     :                                                              */
+/*  Modified : 04/17/2001 removed PV_EOS, PV_END_OF_BUFFER              */
+/*           : 08/22/2002 break up into 2 functions PVDecodeVopHeader and */
+/*                          PVDecodeVopBody                                 */
+/* ======================================================================== */
+OSCL_EXPORT_REF Bool PVDecodeVideoFrame(VideoDecControls *decCtrl, uint8 *buffer[],
+                                        uint32 timestamp[], int32 buffer_size[], uint use_ext_timestamp[], uint8 *currYUV)
+{
+    PV_STATUS status = PV_FAIL;
+    VopHeaderInfo header_info;
+
+    status = (PV_STATUS)PVDecodeVopHeader(decCtrl, buffer, timestamp, buffer_size, &header_info, use_ext_timestamp, currYUV);
+    if (status != PV_TRUE)
+        return PV_FALSE;
+
+    if (PVDecodeVopBody(decCtrl, buffer_size) != PV_TRUE)
+    {
+        return PV_FALSE;
+    }
+
+    return PV_TRUE;
+}
+
+/* ======================================================================== */
+/*  Function : PVDecodeVopHeader()                                          */
+/*  Date     : 08/22/2002                                                   */
+/*  Purpose  : Determine target layer and decode vop header, modified from  */
+/*              original PVDecodeVideoFrame.                                */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Bool PVDecodeVopHeader(VideoDecControls *decCtrl, uint8 *buffer[],
+                       uint32 timestamp[], int32 buffer_size[], VopHeaderInfo *header_info, uint use_ext_timestamp [], uint8 *currYUV)
+{
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+    Vol *currVol;
+    Vop *currVop = video->currVop;
+    Vop **vopHeader = video->vopHeader;
+    BitstreamDecVideo *stream;
+
+    int target_layer;
+
+#ifdef PV_SUPPORT_TEMPORAL_SCALABILITY
+    PV_STATUS status = PV_FAIL;
+    int idx;
+    int32 display_time;
+
+    /* decide which frame to decode next */
+    if (decCtrl->nLayers > 1)
+    {
+        display_time = target_layer = -1;
+        for (idx = 0; idx < decCtrl->nLayers; idx++)
+        {
+            /* do we have data for this layer? */
+            if (buffer_size[idx] <= 0)
+            {
+                timestamp[idx] = -1;
+                continue;
+            }
+
+            /* did the application provide a timestamp for this vop? */
+            if (timestamp[idx] < 0)
+            {
+                if (vopHeader[idx]->timeStamp < 0)
+                {
+                    /* decode the timestamp in the bitstream */
+                    video->currLayer = idx;
+                    stream = video->vol[idx]->bitstream;
+                    BitstreamReset(stream, buffer[idx], buffer_size[idx]);
+
+                    while ((status = DecodeVOPHeader(video, vopHeader[idx], FALSE)) != PV_SUCCESS)
+                    {
+                        /* Try to find a VOP header in the buffer.   08/30/2000. */
+                        if (PVSearchNextM4VFrame(stream) != PV_SUCCESS)
+                        {
+                            /* if we don't have data for enhancement layer, */
+                            /*    don't just stop.   09/07/2000.          */
+                            buffer_size[idx] = 0;
+                            break;
+                        }
+                    }
+                    if (status == PV_SUCCESS)
+                    {
+                        vopHeader[idx]->timeStamp =
+                            timestamp[idx] = CalcVopDisplayTime(video->vol[idx], vopHeader[idx], video->shortVideoHeader);
+                        if (idx == 0) vopHeader[idx]->refSelectCode = 1;
+                    }
+                }
+                else
+                {
+                    /* We've decoded this vop header in the previous run already. */
+                    timestamp[idx] = vopHeader[idx]->timeStamp;
+                }
+            }
+
+            /* Use timestamps to select the next VOP to be decoded */
+            if (timestamp[idx] >= 0 && (display_time < 0 || display_time > timestamp[idx]))
+            {
+                display_time = timestamp[idx];
+                target_layer = idx;
+            }
+            else if (display_time == timestamp[idx])
+            {
+                /* we have to handle either SNR or spatial scalability here. */
+            }
+        }
+        if (target_layer < 0) return PV_FALSE;
+
+        /* set up for decoding the target layer */
+        video->currLayer = target_layer;
+        currVol = video->vol[target_layer];
+        video->bitstream = stream = currVol->bitstream;
+
+        /* We need to decode the vop header if external timestamp   */
+        /*    is provided.    10/04/2000                            */
+        if (vopHeader[target_layer]->timeStamp < 0)
+        {
+            stream = video->vol[target_layer]->bitstream;
+            BitstreamReset(stream, buffer[target_layer], buffer_size[target_layer]);
+
+            while (DecodeVOPHeader(video, vopHeader[target_layer], TRUE) != PV_SUCCESS)
+            {
+                /* Try to find a VOP header in the buffer.   08/30/2000. */
+                if (PVSearchNextM4VFrame(stream) != PV_SUCCESS)
+                {
+                    /* if we don't have data for enhancement layer, */
+                    /*    don't just stop.   09/07/2000.          */
+                    buffer_size[target_layer] = 0;
+                    break;
+                }
+            }
+            video->vol[target_layer]->timeInc_offset = vopHeader[target_layer]->timeInc;
+            video->vol[target_layer]->moduloTimeBase = timestamp[target_layer];
+            vopHeader[target_layer]->timeStamp = timestamp[target_layer];
+            if (target_layer == 0) vopHeader[target_layer]->refSelectCode = 1;
+        }
+    }
+    else /* base layer only decoding */
+    {
+#endif
+        video->currLayer = target_layer = 0;
+        currVol = video->vol[0];
+        video->bitstream = stream = currVol->bitstream;
+        if (buffer_size[0] <= 0) return PV_FALSE;
+        BitstreamReset(stream, buffer[0], buffer_size[0]);
+
+        if (video->shortVideoHeader)
+        {
+            while (DecodeShortHeader(video, vopHeader[0]) != PV_SUCCESS)
+            {
+                if (PVSearchNextH263Frame(stream) != PV_SUCCESS)
+                {
+                    /* There is no vop header in the buffer,    */
+                    /*   clean bitstream buffer.     2/5/2001   */
+                    buffer_size[0] = 0;
+                    if (video->initialized == PV_FALSE)
+                    {
+                        video->displayWidth = video->width = 0;
+                        video->displayHeight = video->height = 0;
+                    }
+                    return PV_FALSE;
+                }
+            }
+
+            if (use_ext_timestamp[0])
+            {
+                /* MTB for H263 is absolute TR */
+                /* following line is equivalent to  round((timestamp[0]*30)/1001);   11/13/2001 */
+                video->vol[0]->moduloTimeBase = 30 * ((timestamp[0] + 17) / 1001) + (30 * ((timestamp[0] + 17) % 1001) / 1001);
+                vopHeader[0]->timeStamp = timestamp[0];
+            }
+            else
+                vopHeader[0]->timeStamp = CalcVopDisplayTime(currVol, vopHeader[0], video->shortVideoHeader);
+        }
+        else
+        {
+            while (DecodeVOPHeader(video, vopHeader[0], FALSE) != PV_SUCCESS)
+            {
+                /* Try to find a VOP header in the buffer.   08/30/2000. */
+                if (PVSearchNextM4VFrame(stream) != PV_SUCCESS)
+                {
+                    /* There is no vop header in the buffer,    */
+                    /*   clean bitstream buffer.     2/5/2001   */
+                    buffer_size[0] = 0;
+                    return PV_FALSE;
+                }
+            }
+
+            if (use_ext_timestamp[0])
+            {
+                video->vol[0]->timeInc_offset = vopHeader[0]->timeInc;
+                video->vol[0]->moduloTimeBase = timestamp[0];  /*  11/12/2001 */
+                vopHeader[0]->timeStamp = timestamp[0];
+            }
+            else
+            {
+                vopHeader[0]->timeStamp = CalcVopDisplayTime(currVol, vopHeader[0], video->shortVideoHeader);
+            }
+        }
+
+        /* set up some base-layer only parameters */
+        vopHeader[0]->refSelectCode = 1;
+#ifdef PV_SUPPORT_TEMPORAL_SCALABILITY
+    }
+#endif
+    timestamp[target_layer] = video->currTimestamp = vopHeader[target_layer]->timeStamp;
+#ifdef PV_MEMORY_POOL
+    vopHeader[target_layer]->yChan = (PIXEL *)currYUV;
+    vopHeader[target_layer]->uChan = (PIXEL *)currYUV + decCtrl->size;
+    vopHeader[target_layer]->vChan = (PIXEL *)(vopHeader[target_layer]->uChan) + (decCtrl->size >> 2);
+#else
+    vopHeader[target_layer]->yChan = currVop->yChan;
+    vopHeader[target_layer]->uChan = currVop->uChan;
+    vopHeader[target_layer]->vChan = currVop->vChan;
+#endif
+    oscl_memcpy(currVop, vopHeader[target_layer], sizeof(Vop));
+
+#ifdef PV_SUPPORT_TEMPORAL_SCALABILITY
+    vopHeader[target_layer]->timeStamp = -1;
+#endif
+    /* put header info into the structure */
+    header_info->currLayer = target_layer;
+    header_info->timestamp = video->currTimestamp;
+    header_info->frameType = (MP4FrameType)currVop->predictionType;
+    header_info->refSelCode = vopHeader[target_layer]->refSelectCode;
+    header_info->quantizer = currVop->quantizer;
+    /***************************************/
+
+    return PV_TRUE;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVDecodeVopBody()                                            */
+/*  Date     : 08/22/2002                                                   */
+/*  Purpose  : Decode vop body after the header is decoded, modified from   */
+/*              original PVDecodeVideoFrame.                                */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Bool PVDecodeVopBody(VideoDecControls *decCtrl, int32 buffer_size[])
+{
+    PV_STATUS status = PV_FAIL;
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+    int target_layer = video->currLayer;
+    Vol *currVol = video->vol[target_layer];
+    Vop *currVop = video->currVop;
+    Vop *prevVop = video->prevVop;
+    Vop *tempVopPtr;
+    int bytes_consumed = 0; /* Record how many bits we used in the buffer.   04/24/2001 */
+
+    int idx;
+
+    if (currVop->vopCoded == 0)                  /*  07/03/2001 */
+    {
+        PV_BitstreamByteAlign(currVol->bitstream);
+        /* We should always clear up bitstream buffer.   10/10/2000 */
+        bytes_consumed = (getPointer(currVol->bitstream) + 7) >> 3;
+
+        if (bytes_consumed > currVol->bitstream->data_end_pos)
+        {
+            bytes_consumed = currVol->bitstream->data_end_pos;
+        }
+
+        if (bytes_consumed < buffer_size[target_layer])
+        {
+            /* If we only consume part of the bits in the buffer, take those */
+            /*  out.     04/24/2001 */
+            /*          oscl_memcpy(buffer[target_layer], buffer[target_layer]+bytes_consumed,
+                            (buffer_size[target_layer]-=bytes_consumed)); */
+            buffer_size[target_layer] -= bytes_consumed;
+        }
+        else
+        {
+            buffer_size[target_layer] = 0;
+        }
+#ifdef PV_MEMORY_POOL
+
+        if (target_layer)
+        {
+            if (video->prevEnhcVop->timeStamp > video->prevVop->timeStamp)
+            {
+                video->prevVop = video->prevEnhcVop;
+            }
+        }
+
+        oscl_memcpy(currVop->yChan, video->prevVop->yChan, (decCtrl->size*3) / 2);
+
+        video->prevVop = prevVop;
+
+        video->concealFrame = currVop->yChan;       /*  07/07/2001 */
+
+        video->vop_coding_type = currVop->predictionType; /*  07/09/01 */
+
+        decCtrl->outputFrame = currVop->yChan;
+
+        /* Swap VOP pointers.  No enhc. frame oscl_memcpy() anymore!   04/24/2001 */
+        if (target_layer)
+        {
+            tempVopPtr = video->prevEnhcVop;
+            video->prevEnhcVop = video->currVop;
+            video->currVop = tempVopPtr;
+        }
+        else
+        {
+            tempVopPtr = video->prevVop;
+            video->prevVop = video->currVop;
+            video->currVop = tempVopPtr;
+        }
+#else
+        if (target_layer)       /* this is necessary to avoid flashback problems   06/21/2002*/
+        {
+            video->prevEnhcVop->timeStamp = currVop->timeStamp;
+        }
+        else
+        {
+            video->prevVop->timeStamp = currVop->timeStamp;
+        }
+#endif
+        video->vop_coding_type = currVop->predictionType; /*  07/09/01 */
+        /* the following is necessary to avoid displaying an notCoded I-VOP at the beginning of a session
+        or after random positioning  07/03/02*/
+        if (currVop->predictionType == I_VOP)
+        {
+            video->vop_coding_type = P_VOP;
+        }
+
+
+        return PV_TRUE;
+    }
+    /* ======================================================= */
+    /*  Decode vop body (if there is no error in the header!)  */
+    /* ======================================================= */
+
+    /* first, we need to select a reference frame */
+    if (decCtrl->nLayers > 1)
+    {
+        if (currVop->predictionType == I_VOP)
+        {
+            /* do nothing here */
+        }
+        else if (currVop->predictionType == P_VOP)
+        {
+            switch (currVop->refSelectCode)
+            {
+                case 0 : /* most recently decoded enhancement vop */
+                    /* Setup video->prevVop before we call PV_DecodeVop().   04/24/2001 */
+                    if (video->prevEnhcVop->timeStamp >= video->prevVop->timeStamp)
+                        video->prevVop = video->prevEnhcVop;
+                    break;
+
+                case 1 : /* most recently displayed base-layer vop */
+                    if (target_layer)
+                    {
+                        if (video->prevEnhcVop->timeStamp > video->prevVop->timeStamp)
+                            video->prevVop = video->prevEnhcVop;
+                    }
+                    break;
+
+                case 2 : /* next base-layer vop in display order */
+                    break;
+
+                case 3 : /* temporally coincident base-layer vop (no MV's) */
+                    break;
+            }
+        }
+        else /* we have a B-Vop */
+        {
+            mp4dec_log("DecodeVideoFrame(): B-VOP not supported.\n");
+        }
+    }
+
+    /* This is for the calculation of the frame rate and bitrate. */
+    idx = ++video->frame_idx % BITRATE_AVERAGE_WINDOW;
+
+    /* Calculate bitrate for this layer.   08/23/2000 */
+    status = PV_DecodeVop(video);
+    video->nBitsPerVop[idx] = getPointer(currVol->bitstream);
+    video->prevTimestamp[idx] = currVop->timeStamp;
+
+    /* restore video->prevVop after PV_DecodeVop().   04/24/2001 */
+//  if (currVop->refSelectCode == 0) video->prevVop = prevVop;
+    video->prevVop = prevVop;
+
+    /* Estimate the frame rate.   08/23/2000 */
+    video->duration = video->prevTimestamp[idx];
+    video->duration -= video->prevTimestamp[(++idx)%BITRATE_AVERAGE_WINDOW];
+    if (video->duration > 0)
+    { /* Only update framerate when the timestamp is right */
+        video->frameRate = (int)(FRAMERATE_SCALE) / video->duration;
+    }
+
+    /* We should always clear up bitstream buffer.   10/10/2000 */
+    bytes_consumed = (getPointer(currVol->bitstream) + 7) >> 3; /*  11/4/03 */
+
+    if (bytes_consumed > currVol->bitstream->data_end_pos)
+    {
+        bytes_consumed = currVol->bitstream->data_end_pos;
+    }
+
+    if (bytes_consumed < buffer_size[target_layer])
+    {
+        /* If we only consume part of the bits in the buffer, take those */
+        /*  out.     04/24/2001 */
+        /*      oscl_memcpy(buffer[target_layer], buffer[target_layer]+bytes_consumed,
+                    (buffer_size[target_layer]-=bytes_consumed)); */
+        buffer_size[target_layer] -= bytes_consumed;
+    }
+    else
+    {
+        buffer_size[target_layer] = 0;
+    }
+    switch (status)
+    {
+        case PV_FAIL :
+            return PV_FALSE;        /* this will take care of concealment if we lose whole frame  */
+
+        case PV_END_OF_VOP :
+            /* we may want to differenciate PV_END_OF_VOP and PV_SUCCESS */
+            /*    in the future.     05/10/2000                      */
+
+        case PV_SUCCESS :
+            /* Nohting is wrong :). */
+
+
+            video->concealFrame = video->currVop->yChan;       /*  07/07/2001 */
+
+            video->vop_coding_type = video->currVop->predictionType; /*  07/09/01 */
+
+            decCtrl->outputFrame = video->currVop->yChan;
+
+            /* Swap VOP pointers.  No enhc. frame oscl_memcpy() anymore!   04/24/2001 */
+            if (target_layer)
+            {
+                tempVopPtr = video->prevEnhcVop;
+                video->prevEnhcVop = video->currVop;
+                video->currVop = tempVopPtr;
+            }
+            else
+            {
+                tempVopPtr = video->prevVop;
+                video->prevVop = video->currVop;
+                video->currVop = tempVopPtr;
+            }
+            break;
+
+        default :
+            /* This will never happen */
+            break;
+    }
+
+    return PV_TRUE;
+}
+
+#ifdef PV_MEMORY_POOL
+OSCL_EXPORT_REF void PVSetReferenceYUV(VideoDecControls *decCtrl, uint8 *YUV)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    video->prevVop->yChan = (PIXEL *)YUV;
+    video->prevVop->uChan = (PIXEL *)YUV + video->size;
+    video->prevVop->vChan = (PIXEL *)video->prevVop->uChan + (decCtrl->size >> 2);
+    oscl_memset(video->prevVop->yChan, 16, sizeof(uint8)*decCtrl->size);     /*  10/31/01 */
+    oscl_memset(video->prevVop->uChan, 128, sizeof(uint8)*decCtrl->size / 2);
+    video->concealFrame = video->prevVop->yChan;               /*  07/07/2001 */
+    decCtrl->outputFrame = video->prevVop->yChan;              /*  06/19/2002 */
+}
+#endif
+
+
+/* ======================================================================== */
+/*  Function : VideoDecoderErrorDetected()                                  */
+/*  Date     : 06/20/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : This function will be called everytime an error int the      */
+/*              bitstream is detected.                                      */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+uint VideoDecoderErrorDetected(VideoDecData *)
+{
+    /* This is only used for trapping bitstream error for debuging */
+    return 0;
+}
+
+#ifdef ENABLE_LOG
+#include <stdio.h>
+#include <stdarg.h>
+/* ======================================================================== */
+/*  Function : m4vdec_dprintf()                                             */
+/*  Date     : 08/15/2000                                                   */
+/*  Purpose  : This is a function that logs messages in the mpeg4 video     */
+/*             decoder.  We can call the standard PacketVideo PVMessage     */
+/*             from inside this function if necessary.                      */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Note     : To turn on the logging, LOG_MP4DEC_MESSAGE must be defined   */
+/*              when compiling this file (only this file).                  */
+/*  Modified :                                                              */
+/* ======================================================================== */
+void m4vdec_dprintf(char *format, ...)
+{
+    FILE *log_fp;
+    va_list args;
+    va_start(args, format);
+
+    /* open the log file */
+    log_fp = fopen("\\mp4dec_log.txt", "a+");
+    if (log_fp == NULL) return;
+    /* output the message */
+    vfprintf(log_fp, format, args);
+    fclose(log_fp);
+
+    va_end(args);
+}
+#endif
+
+
+/* ======================================================================== */
+/*  Function : IsIntraFrame()                                               */
+/*  Date     : 05/29/2000                                                   */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : The most recently decoded frame is an Intra frame.           */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Bool IsIntraFrame(VideoDecControls *decCtrl)
+{
+    VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
+    return (video->vop_coding_type == I_VOP);
+}
+
+/* ======================================================================== */
+/*  Function : PVDecPostProcess()                                           */
+/*  Date     : 01/09/2002                                                   */
+/*  Purpose  : PostProcess one video frame and return a YUV-12 image.       */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+void PVDecPostProcess(VideoDecControls *decCtrl, uint8 *outputYUV)
+{
+    uint8 *outputBuffer;
+#ifdef PV_POSTPROC_ON
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+    int32 tmpvar;
+    if (outputYUV)
+    {
+        outputBuffer = outputYUV;
+    }
+    else
+    {
+        if (video->postFilterType)
+        {
+            outputBuffer = video->currVop->yChan;
+        }
+        else
+        {
+            outputBuffer = decCtrl->outputFrame;
+        }
+    }
+
+    if (video->postFilterType)
+    {
+        /* Post-processing,  */
+        PostFilter(video, video->postFilterType, outputBuffer);
+    }
+    else
+    {
+        if (outputYUV)
+        {
+            /* Copy decoded frame to the output buffer. */
+            tmpvar = (int32)video->width * video->height;
+            oscl_memcpy(outputBuffer, decCtrl->outputFrame, tmpvar*3 / 2);           /*  3/3/01 */
+        }
+    }
+#else
+    outputBuffer = decCtrl->outputFrame;
+    outputYUV;
+#endif
+    decCtrl->outputFrame = outputBuffer;
+    return;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVDecSetReference(VideoDecControls *decCtrl, uint8 *refYUV,  */
+/*                              int32 timestamp)                            */
+/*  Date     : 07/22/2003                                                   */
+/*  Purpose  : Get YUV reference frame from external source.                */
+/*  In/out   : YUV 4-2-0 frame containing new reference frame in the same   */
+/*   : dimension as original, i.e., doesn't have to be multiple of 16 !!!.  */
+/*  Return   :                                                              */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Bool PVDecSetReference(VideoDecControls *decCtrl, uint8 *refYUV, uint32 timestamp)
+{
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+    Vop *prevVop = video->prevVop;
+    int width = video->width;
+    uint8 *dstPtr, *orgPtr, *dstPtr2, *orgPtr2;
+    int32 size = (int32)width * video->height;
+
+
+    /* set new parameters */
+    prevVop->timeStamp = timestamp;
+    prevVop->predictionType = I_VOP;
+
+    dstPtr = prevVop->yChan;
+    orgPtr = refYUV;
+    oscl_memcpy(dstPtr, orgPtr, size);
+    dstPtr = prevVop->uChan;
+    dstPtr2 = prevVop->vChan;
+    orgPtr = refYUV + size;
+    orgPtr2 = orgPtr + (size >> 2);
+    oscl_memcpy(dstPtr, orgPtr, (size >> 2));
+    oscl_memcpy(dstPtr2, orgPtr2, (size >> 2));
+
+    video->concealFrame = video->prevVop->yChan;
+    video->vop_coding_type = I_VOP;
+    decCtrl->outputFrame = video->prevVop->yChan;
+
+    return PV_TRUE;
+}
+
+/* ======================================================================== */
+/*  Function : PVDecSetEnhReference(VideoDecControls *decCtrl, uint8 *refYUV,   */
+/*                              int32 timestamp)                            */
+/*  Date     : 07/23/2003                                                   */
+/*  Purpose  : Get YUV enhance reference frame from external source.        */
+/*  In/out   : YUV 4-2-0 frame containing new reference frame in the same   */
+/*   : dimension as original, i.e., doesn't have to be multiple of 16 !!!.  */
+/*  Return   :                                                              */
+/*  Note     :                                                              */
+/*  Modified :                                                              */
+/* ======================================================================== */
+Bool PVDecSetEnhReference(VideoDecControls *decCtrl, uint8 *refYUV, uint32 timestamp)
+{
+    VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
+    Vop *prevEnhcVop = video->prevEnhcVop;
+    uint8 *dstPtr, *orgPtr, *dstPtr2, *orgPtr2;
+    int32 size = (int32) video->width * video->height;
+
+    if (video->numberOfLayers <= 1)
+        return PV_FALSE;
+
+
+    /* set new parameters */
+    prevEnhcVop->timeStamp = timestamp;
+    prevEnhcVop->predictionType = I_VOP;
+
+    dstPtr = prevEnhcVop->yChan;
+    orgPtr = refYUV;
+    oscl_memcpy(dstPtr, orgPtr, size);
+    dstPtr = prevEnhcVop->uChan;
+    dstPtr2 = prevEnhcVop->vChan;
+    orgPtr = refYUV + size;
+    orgPtr2 = orgPtr + (size >> 2);
+    oscl_memcpy(dstPtr, orgPtr, (size >> 2));
+    oscl_memcpy(dstPtr2, orgPtr2, (size >> 2));
+    video->concealFrame = video->prevEnhcVop->yChan;
+    video->vop_coding_type = I_VOP;
+    decCtrl->outputFrame = video->prevEnhcVop->yChan;
+
+    return PV_TRUE;
+}
+
+
+/* ======================================================================== */
+/*  Function : PVGetVolInfo()                                               */
+/*  Date     : 08/06/2003                                                   */
+/*  Purpose  : Get the vol info(only base-layer).                           */
+/*  In/out   :                                                              */
+/*  Return   :                                                              */
+/*  Note     :                                                              */
+/*  Modified : 06/24/2004                                                   */
+/* ======================================================================== */
+Bool PVGetVolInfo(VideoDecControls *decCtrl, VolInfo *pVolInfo)
+{
+    Vol *currVol;
+
+    if (pVolInfo == NULL || decCtrl == NULL || decCtrl->videoDecoderData == NULL ||
+            ((VideoDecData *)decCtrl->videoDecoderData)->vol[0] == NULL) return PV_FALSE;
+
+    currVol = ((VideoDecData *)(decCtrl->videoDecoderData))->vol[0];
+
+    // get the VOL info
+    pVolInfo->shortVideoHeader = (int32)((VideoDecData *)(decCtrl->videoDecoderData))->shortVideoHeader;
+    pVolInfo->dataPartitioning = (int32)currVol->dataPartitioning;
+    pVolInfo->errorResDisable  = (int32)currVol->errorResDisable;
+    pVolInfo->useReverseVLC    = (int32)currVol->useReverseVLC;
+    pVolInfo->scalability      = (int32)currVol->scalability;
+    pVolInfo->nbitsTimeIncRes  = (int32)currVol->nbitsTimeIncRes;
+    pVolInfo->profile_level_id = (int32)currVol->profile_level_id;
+
+    return PV_TRUE;
+}
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/scaling.h b/media/libstagefright/codecs/m4v_h263/dec/src/scaling.h
new file mode 100644
index 0000000..26abbae
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/scaling.h
@@ -0,0 +1,52 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    extern const int32 scale[63];
+
+#define PV_GET_ROW(a,b) ((a) / (b))
+
+    /*----------------------------------------------------------------------------
+    ; SIMPLE TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; ENUMERATED TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; STRUCTURES TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; GLOBAL FUNCTION DEFINITIONS
+    ; Function Prototype declaration
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; END
+    ----------------------------------------------------------------------------*/
+#ifdef __cplusplus
+}
+#endif
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/scaling_tab.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/scaling_tab.cpp
new file mode 100644
index 0000000..a1f95aa
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/scaling_tab.cpp
@@ -0,0 +1,88 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+
+#include    "mp4dec_api.h"
+#include    "mp4def.h"
+#include    "scaling.h"
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+
+/* this scaling can be used for dividing values up to 3292             07/10/01 */
+const int32 scale[63] = {0, 262145, 131073, 87382, 65537, 52430, 43692, 37450, 32769, 29128,
+                         26215, 23832, 21846, 20166, 18726, 17477, 16385, 15421, 14565, 13798,
+                         13108, 12484, 11917, 11399, 10924, 10487, 10083, 9710, 9363, 9040,
+                         8739, 8457, 8193, 7945, 7711, 7491, 7283, 7086, 6900, 6723, 6555, 6395,
+                         6243, 6097, 5959, 5826, 5700, 5579, 5462, 5351, 5244, 5141, 5042, 4947, 4856,
+                         4767, 4682, 4600, 4521, 4444, 4370, 4298, 4229
+                        };
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Define all local variables
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Function body here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Return nothing or data or data pointer
+----------------------------------------------------------------------------*/
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/vlc_dec_tab.h b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_dec_tab.h
new file mode 100644
index 0000000..404cc8b
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_dec_tab.h
@@ -0,0 +1,215 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+*     -------------------------------------------------------------------   *
+*                    MPEG-4 Simple Profile Video Decoder                    *
+*     -------------------------------------------------------------------   *
+*
+* This software module was originally developed by
+*
+*   Paulo Nunes (IST / ACTS-MoMuSyS)
+*
+* and edited by
+*
+*   Robert Danielsen (Telenor / ACTS-MoMuSyS)
+*
+* in the course of development of the MPEG-4 Video (ISO/IEC 14496-2) standard.
+* This software module is an implementation of a part of one or more MPEG-4
+* Video (ISO/IEC 14496-2) tools as specified by the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* ISO/IEC gives users of the MPEG-4 Video (ISO/IEC 14496-2) standard free
+* license to this software module or modifications thereof for use in hardware
+* or software products claiming conformance to the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* Those intending to use this software module in hardware or software products
+* are advised that its use may infringe existing patents. The original
+* developer of this software module and his/her company, the subsequent
+* editors and their companies, and ISO/IEC have no liability for use of this
+* software module or modifications thereof in an implementation. Copyright is
+* not released for non MPEG-4 Video (ISO/IEC 14496-2) Standard conforming
+* products.
+*
+* ACTS-MoMuSys partners retain full right to use the code for his/her own
+* purpose, assign or donate the code to a third party and to inhibit third
+* parties from using the code for non MPEG-4 Video (ISO/IEC 14496-2) Standard
+* conforming products. This copyright notice must be included in all copies or
+* derivative works.
+*
+* Copyright (c) 1996
+*
+*****************************************************************************
+***********************************************************HeaderBegin*******
+*
+* File: vlc_dec_tab.h
+*
+* Author:   Paulo Nunes (IST) - Paulo.Nunes@it.ist.utl.pt
+* Created:  1-Mar-96
+*
+* Description: This file contains the VLC tables for module which deals
+*       with VLC decoding.
+*
+* Notes:    This file was created based on tmndecode
+*       Written by Karl Olav Lillevold <kol@nta.no>,
+*       1995 Telenor R&D.
+*       Donated to the Momusys-project as background code by
+*       Telenor.
+*
+*       based on mpeg2decode, (C) 1994, MPEG Software Simulation Group
+*       and mpeg2play, (C) 1994 Stefan Eckart
+*                         <stefan@lis.e-technik.tu-muenchen.de>
+*
+*
+* Modified:  9-May-96 Paulo Nunes: Reformatted. New headers.
+*       14-May-96 Paulo Nunes: Changed TMNMVtabs according to VM2.1.
+*   04.11.96 Robert Danielsen: Added three new tables for coding
+*           of Intra luminance coefficients (VM 4.0)
+*      01.05.97 Luis Ducla-Soares: added VM7.0 Reversible VLC tables (RVLC).
+*      13.05.97 Minhua Zhou: added VlC tables for CBPYtab2 CBPYtab3,
+*   revised  CBPYtab
+*
+***********************************************************HeaderEnd*********
+
+This module is a header file for "vlc_decode.c".  The table data actually
+resides in "vlc_tab.c".
+
+
+------------------------------------------------------------------------------
+*/
+
+/*----------------------------------------------------------------------------
+; CONTINUE ONLY IF NOT ALREADY DEFINED
+----------------------------------------------------------------------------*/
+#ifndef vlc_dec_tab_H
+#define vlc_dec_tab_H
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+#include "mp4def.h"
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here.
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; EXTERNAL VARIABLES REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    extern const VLCshorttab PV_TMNMVtab0[];
+
+    extern const VLCshorttab PV_TMNMVtab1[];
+
+    extern const VLCshorttab PV_TMNMVtab2[];
+
+    extern const VLCshorttab PV_MCBPCtab[];
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    extern const VLCshorttab PV_MCBPCtab1[];
+#endif
+    extern const VLCshorttab PV_MCBPCtabintra[];
+
+    /* Table for separate mode MCBPC, for coding DQUANT-flag and CBPC */
+
+    extern const VLCshorttab MCBPCtab_sep[32];
+
+    extern const VLCshorttab PV_CBPYtab[48];
+
+    extern const VLCshorttab CBPYtab2[16];
+
+    extern const VLCshorttab CBPYtab3[64];
+
+    extern const VLCtab2 PV_DCT3Dtab0[];
+
+
+    extern const VLCtab2 PV_DCT3Dtab1[];
+
+
+    extern const VLCtab2 PV_DCT3Dtab2[];
+
+    /* New tables for Intra luminance blocks */
+
+    extern const VLCtab2 PV_DCT3Dtab3[];
+
+    extern const VLCtab2 PV_DCT3Dtab4[];
+
+    extern const VLCtab2 PV_DCT3Dtab5[];
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    /* Annex I tables */
+    extern const VLCtab2 PV_DCT3Dtab6[];
+
+    extern const VLCtab2 PV_DCT3Dtab7[];
+
+    extern const VLCtab2 PV_DCT3Dtab8[];
+#endif
+    /* RVLC tables */
+    extern const int ptrRvlcTab[];
+
+    extern const VLCtab2 RvlcDCTtabIntra[];
+
+    extern const VLCtab2 RvlcDCTtabInter[];
+
+    /*----------------------------------------------------------------------------
+    ; SIMPLE TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+
+    /*----------------------------------------------------------------------------
+    ; ENUMERATED TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; STRUCTURES TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; GLOBAL FUNCTION DEFINITIONS
+    ; Function Prototype declaration
+    ----------------------------------------------------------------------------*/
+
+
+    /*----------------------------------------------------------------------------
+    ; END
+    ----------------------------------------------------------------------------*/
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+
+
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/vlc_decode.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_decode.cpp
new file mode 100644
index 0000000..f7192b1
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_decode.cpp
@@ -0,0 +1,1636 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+*     -------------------------------------------------------------------       *
+*                    MPEG-4 Simple Profile Video Decoder                        *
+*     -------------------------------------------------------------------       *
+*
+* This software module was originally developed by
+*
+*   Paulo Nunes (IST / ACTS-MoMuSyS)
+*   Robert Danielsen (Telenor / ACTS-MoMuSyS)
+*
+* in the course of development of the MPEG-4 Video (ISO/IEC 14496-2) standard.
+* This software module is an implementation of a part of one or more MPEG-4
+* Video (ISO/IEC 14496-2) tools as specified by the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* ISO/IEC gives users of the MPEG-4 Video (ISO/IEC 14496-2) standard free
+* license to this software module or modifications thereof for use in hardware
+* or software products claiming conformance to the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* Those intending to use this software module in hardware or software products
+* are advised that its use may infringe existing patents. The original
+* developer of this software module and his/her company, the subsequent
+* editors and their companies, and ISO/IEC have no liability for use of this
+* software module or modifications thereof in an implementation. Copyright is
+* not released for non MPEG-4 Video (ISO/IEC 14496-2) Standard conforming
+* products.
+*
+* ACTS-MoMuSys partners retain full right to use the code for his/her own
+* purpose, assign or donate the code to a third party and to inhibit third
+* parties from using the code for non MPEG-4 Video (ISO/IEC 14496-2) Standard
+* conforming products. This copyright notice must be included in all copies or
+* derivative works.
+*
+* Copyright (c) 1996
+*
+*****************************************************************************/
+
+/***********************************************************HeaderBegin*******
+*
+* File: vlc_dec.c
+*
+* Author:   Paulo Nunes (IST) - Paulo.Nunes@lx.it.pt
+* Created:  1-Mar-96
+*
+* Description: This file contains the VLC functions needed to decode a
+*       bitstream.
+*
+* Notes:
+*       The functions contained in this file were adapted from
+*       tmndecode
+*       Written by Karl Olav Lillevold <kol@nta.no>,
+*       1995 Telenor R&D.
+*       Donated to the Momusys-project as background code by
+*       Telenor.
+*
+*       based on mpeg2decode, (C) 1994, MPEG Software Simulation Group
+*       and mpeg2play, (C) 1994 Stefan Eckart
+*                   <stefan@lis.e-technik.tu-muenchen.de>
+*
+*
+* Modified: 9-May-96 Paulo Nunes: Reformatted. New headers.
+*              17-Jan-97 Jan De Lameillieure (HHI) : corrected in
+*              01.05.97 Luis Ducla-Soares: added RvlcDecTCOEF() to allow decoding
+*                                          of Reversible VLCs.
+*       09.03.98 Paulo Nunes: Cleaning.
+*
+***********************************************************HeaderEnd*********/
+
+#include "mp4dec_lib.h"
+#include "vlc_dec_tab.h"
+#include "vlc_decode.h"
+#include "bitstream.h"
+#include "max_level.h"
+
+
+/* ====================================================================== /
+    Function : DecodeUserData()
+    Date     : 04/10/2000
+    History  :
+    Modified : 04/16/2001 : removed status checking of PV_BitstreamFlushBits
+
+        This is simply a realization of the user_data() function
+        in the ISO/IEC 14496-2 manual.
+/ ====================================================================== */
+PV_STATUS DecodeUserData(BitstreamDecVideo *stream)
+{
+    PV_STATUS status;
+    uint32 code;
+
+    BitstreamReadBits32HC(stream);
+    BitstreamShowBits32(stream, 24, &code);
+
+    while (code != 1)
+    {
+        /* Discard user data for now.   04/05/2000 */
+        BitstreamReadBits16(stream, 8);
+        BitstreamShowBits32(stream, 24, &code);
+        status = BitstreamCheckEndBuffer(stream);
+        if (status == PV_END_OF_VOP) return status;    /*  03/19/2002 */
+    }
+    return PV_SUCCESS;
+}
+
+
+
+/***********************************************************CommentBegin******
+*
+*       3/10/00  : initial modification to the
+*                new PV-Decoder Lib format.
+*       3/29/00  : added return code check to some functions and
+*                optimize the code.
+*
+***********************************************************CommentEnd********/
+PV_STATUS PV_GetMBvectors(VideoDecData *video, uint mode)
+{
+    PV_STATUS status;
+    BitstreamDecVideo *stream = video->bitstream;
+    int  f_code_f = video->currVop->fcodeForward;
+    int  vlc_code_mag;
+
+
+    MOT *mot_x = video->motX;
+    MOT *mot_y = video->motY;
+
+    int k, offset;
+    int x_pos = video->mbnum_col;
+    int y_pos = video->mbnum_row;
+    int doubleWidth = video->nMBPerRow << 1;
+    int pos = (x_pos + y_pos * doubleWidth) << 1;
+    MOT mvx = 0, mvy = 0;
+
+
+    if (f_code_f == 1)
+    {
+#ifdef PV_ANNEX_IJKT_SUPPORT
+        if (mode == MODE_INTER4V || mode == MODE_INTER4V_Q)
+#else
+        if (mode == MODE_INTER4V)
+#endif
+        {
+            for (k = 0; k < 4; k++)
+            {
+                offset = (k & 1) + (k >> 1) * doubleWidth;
+                mv_prediction(video, k, &mvx, &mvy);
+                /* decode component x */
+                status = PV_VlcDecMV(stream, &vlc_code_mag);
+                if (status != PV_SUCCESS)
+                {
+                    return status;
+                }
+
+                mvx += (MOT)vlc_code_mag;
+                mvx = (MOT)(((mvx + 32) & 0x3F) - 32);
+
+
+                status = PV_VlcDecMV(stream, &vlc_code_mag);
+                if (status != PV_SUCCESS)
+                {
+                    return status;
+                }
+
+                mvy += (MOT)vlc_code_mag;
+                mvy = (MOT)(((mvy + 32) & 0x3F) - 32);
+
+                mot_x[pos+offset] = (MOT) mvx;
+                mot_y[pos+offset] = (MOT) mvy;
+            }
+        }
+        else
+        {
+            mv_prediction(video, 0, &mvx, &mvy);
+            /* For PVOPs, field  appears only in MODE_INTER & MODE_INTER_Q */
+            status = PV_VlcDecMV(stream, &vlc_code_mag);
+            if (status != PV_SUCCESS)
+            {
+                return status;
+            }
+
+            mvx += (MOT)vlc_code_mag;
+            mvx = (MOT)(((mvx + 32) & 0x3F) - 32);
+
+
+            status = PV_VlcDecMV(stream, &vlc_code_mag);
+            if (status != PV_SUCCESS)
+            {
+                return status;
+            }
+
+
+            mvy += (MOT)vlc_code_mag;
+            mvy = (MOT)(((mvy + 32) & 0x3F) - 32);
+
+
+            mot_x[pos] = mot_x[pos+1] = (MOT) mvx;
+            mot_y[pos] = mot_y[pos+1] = (MOT) mvy;
+            pos += doubleWidth;
+            mot_x[pos] = mot_x[pos+1] = (MOT) mvx;
+            mot_y[pos] = mot_y[pos+1] = (MOT) mvy;
+        }
+    }
+    else
+    {
+#ifdef PV_ANNEX_IJKT_SUPPORT
+        if (mode == MODE_INTER4V || mode == MODE_INTER4V_Q)
+#else
+        if (mode == MODE_INTER4V)
+#endif
+        {
+            for (k = 0; k < 4; k++)
+            {
+                offset = (k & 1) + (k >> 1) * doubleWidth;
+                mv_prediction(video, k, &mvx, &mvy);
+                status = PV_DecodeMBVec(stream, &mvx, &mvy, f_code_f);
+                mot_x[pos+offset] = (MOT) mvx;
+                mot_y[pos+offset] = (MOT) mvy;
+                if (status != PV_SUCCESS)
+                {
+                    return status;
+                }
+            }
+        }
+        else
+        {
+            mv_prediction(video, 0, &mvx, &mvy);
+            /* For PVOPs, field  appears only in MODE_INTER & MODE_INTER_Q */
+            status = PV_DecodeMBVec(stream, &mvx, &mvy, f_code_f);
+            mot_x[pos] = mot_x[pos+1] = (MOT) mvx;
+            mot_y[pos] = mot_y[pos+1] = (MOT) mvy;
+            pos += doubleWidth;
+            mot_x[pos] = mot_x[pos+1] = (MOT) mvx;
+            mot_y[pos] = mot_y[pos+1] = (MOT) mvy;
+            if (status != PV_SUCCESS)
+            {
+                return status;
+            }
+        }
+    }
+    return PV_SUCCESS;
+}
+
+
+/***********************************************************CommentBegin******
+*       3/10/00  : initial modification to the
+*                new PV-Decoder Lib format.
+*       3/29/00  : added return code check to some functions
+*       5/10/00  : check whether the decoded vector is legal.
+*       4/17/01  : use MOT type
+***********************************************************CommentEnd********/
+PV_STATUS PV_DecodeMBVec(BitstreamDecVideo *stream, MOT *mv_x, MOT *mv_y, int f_code_f)
+{
+    PV_STATUS status;
+    int  vlc_code_magx, vlc_code_magy;
+    int  residualx = 0, residualy = 0;
+
+    /* decode component x */
+    status = PV_VlcDecMV(stream, &vlc_code_magx);
+    if (status != PV_SUCCESS)
+    {
+        return status;
+    }
+
+    if (vlc_code_magx)
+    {
+        residualx = (int) BitstreamReadBits16_INLINE(stream, (int)(f_code_f - 1));
+    }
+
+
+    /* decode component y */
+    status = PV_VlcDecMV(stream, &vlc_code_magy);
+    if (status != PV_SUCCESS)
+    {
+        return status;
+    }
+
+    if (vlc_code_magy)
+    {
+        residualy = (int) BitstreamReadBits16_INLINE(stream, (int)(f_code_f - 1));
+    }
+
+
+    if (PV_DeScaleMVD(f_code_f, residualx, vlc_code_magx, mv_x) != PV_SUCCESS)
+    {
+        return PV_FAIL;
+    }
+
+    if (PV_DeScaleMVD(f_code_f, residualy, vlc_code_magy, mv_y) != PV_SUCCESS)
+    {
+        return PV_FAIL;
+    }
+
+    return PV_SUCCESS;
+}
+
+
+/***********************************************************CommentBegin******
+*       3/31/2000 : initial modification to the new PV-Decoder Lib format.
+*       5/10/2000 : check to see if the decoded vector falls within
+*                           the legal fcode range.
+*
+***********************************************************CommentEnd********/
+PV_STATUS PV_DeScaleMVD(
+    int  f_code,       /* <-- MV range in 1/2 units: 1=32,2=64,...,7=2048     */
+    int  residual,     /* <-- part of the MV Diff. FLC coded                  */
+    int  vlc_code_mag, /* <-- part of the MV Diff. VLC coded                  */
+    MOT  *vector       /* --> Obtained MV component in 1/2 units              */
+)
+{
+    int   half_range = (1 << (f_code + 4));
+    int   mask = (half_range << 1) - 1;
+    int   diff_vector;
+
+
+    if (vlc_code_mag == 0)
+    {
+        diff_vector = vlc_code_mag;
+    }
+    else
+    {
+        diff_vector = ((PV_ABS(vlc_code_mag) - 1) << (f_code - 1)) + residual + 1;
+        if (vlc_code_mag < 0)
+        {
+            diff_vector = -diff_vector;
+        }
+    }
+
+    *vector += (MOT)(diff_vector);
+
+    *vector = (MOT)((*vector + half_range) & mask) - half_range;
+
+    return PV_SUCCESS;
+}
+
+
+
+void mv_prediction(
+    VideoDecData *video,
+    int block,
+    MOT *mvx,
+    MOT *mvy
+)
+{
+    /*----------------------------------------------------------------------------
+    ; Define all local variables
+    ----------------------------------------------------------------------------*/
+    MOT *motxdata = video->motX;
+    MOT *motydata = video->motY;
+    int mbnum_col = video->mbnum_col;
+    int mbnum_row = video->mbnum_row;
+    uint8 *slice_nb = video->sliceNo;
+    int nMBPerRow = video->nMBPerRow;
+    int nMVPerRow = nMBPerRow << 1;
+    int mbnum = video->mbnum;
+    int p1x = 0, p2x = 0, p3x = 0;
+    int p1y = 0, p2y = 0, p3y = 0;
+    int rule1 = 0, rule2 = 0, rule3 = 0;
+    int     indx;
+
+    indx = ((mbnum_col << 1) + (block & 1)) + ((mbnum_row << 1)  + (block >> 1)) * nMVPerRow - 1; /* left block */
+
+    if (block & 1)           /* block 1, 3 */
+    {
+        p1x = motxdata[indx];
+        p1y = motydata[indx];
+        rule1 = 1;
+    }
+    else                    /* block 0, 2 */
+    {
+        if (mbnum_col > 0 && slice_nb[mbnum] == slice_nb[mbnum-1])
+        {
+            p1x = motxdata[indx];
+            p1y = motydata[indx];
+            rule1 = 1;
+        }
+    }
+
+    indx = indx + 1 - nMVPerRow; /* upper_block */
+    if (block >> 1)
+    {
+        indx -= (block & 1);
+        p2x = motxdata[indx];
+        p2y = motydata[indx];
+        p3x = motxdata[indx + 1];
+        p3y = motydata[indx + 1];
+        rule2 = rule3 = 1;
+    }
+    else
+    {                           /* block 0,1 */
+        if (mbnum_row)
+        {
+            if (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])
+            {
+                p2x = motxdata[indx];
+                p2y = motydata[indx];
+                rule2 = 1;
+            }
+            if (mbnum_col < nMBPerRow - 1 && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow+1])
+            {
+                indx = indx + 2 - (block & 1);
+                p3x = motxdata[indx];
+                p3y = motydata[indx];
+                rule3 = 1;
+            }
+        }
+    }
+
+    if (rule1 + rule2 + rule3 > 1)
+    {
+        *mvx = (MOT)PV_MEDIAN(p1x, p2x, p3x);
+        *mvy = (MOT)PV_MEDIAN(p1y, p2y, p3y);
+    }
+    else if (rule1 + rule2 + rule3 == 1)
+    {
+        /* two of three are zero */
+        *mvx = (MOT)(p1x + p2x + p3x);
+        *mvy = (MOT)(p1y + p2y + p3y);
+    }
+    else
+    {
+        /* all MBs are outside the VOP */
+        *mvx = *mvy = 0;
+    }
+    /*----------------------------------------------------------------------------
+    ; Return nothing or data or data pointer
+    ----------------------------------------------------------------------------*/
+    return;
+}
+
+/***********************************************************CommentBegin******
+*
+*       3/30/2000 : initial modification to the new PV-Decoder Lib format.
+*       4/16/2001 : removed checking of status for PV_BitstreamFlushBits
+***********************************************************CommentEnd********/
+
+PV_STATUS PV_VlcDecMV(BitstreamDecVideo *stream, int *mv)
+{
+    PV_STATUS status = PV_SUCCESS;
+    uint code;
+
+    BitstreamShow13Bits(stream, &code);
+
+    if (code >> 12)
+    {
+        *mv = 0; /* Vector difference = 0 */
+        PV_BitstreamFlushBits(stream, 1);
+        return PV_SUCCESS;
+    }
+
+    if (code >= 512)
+    {
+        code = (code >> 8) - 2;
+        PV_BitstreamFlushBits(stream, PV_TMNMVtab0[code].len + 1);
+        *mv = PV_TMNMVtab0[code].val;
+        return status;
+    }
+
+    if (code >= 128)
+    {
+        code = (code >> 2) - 32;
+        PV_BitstreamFlushBits(stream, PV_TMNMVtab1[code].len + 1);
+        *mv = PV_TMNMVtab1[code].val;
+        return status;
+    }
+
+    if (code < 4)
+    {
+        *mv = -1;
+        return PV_FAIL;
+    }
+
+    code -= 4;
+
+    PV_BitstreamFlushBits(stream, PV_TMNMVtab2[code].len + 1);
+
+    *mv = PV_TMNMVtab2[code].val;
+    return status;
+}
+
+
+/***********************************************************CommentBegin******
+*       3/30/2000 : initial modification to the new PV-Decoder Lib
+*                           format and the change of error-handling method.
+*       4/16/01   : removed status checking of PV_BitstreamFlushBits
+***********************************************************CommentEnd********/
+
+int PV_VlcDecMCBPC_com_intra(BitstreamDecVideo *stream)
+{
+    uint code;
+
+    BitstreamShowBits16(stream, 9, &code);
+
+
+    if (code < 8)
+    {
+        return VLC_CODE_ERROR;
+    }
+
+    code >>= 3;
+
+    if (code >= 32)
+    {
+        PV_BitstreamFlushBits(stream, 1);
+        return 3;
+    }
+
+    PV_BitstreamFlushBits(stream, PV_MCBPCtabintra[code].len);
+
+    return PV_MCBPCtabintra[code].val;
+}
+
+
+/***********************************************************CommentBegin******
+*
+*       3/30/2000 : initial modification to the new PV-Decoder Lib
+*                           format and the change of error-handling method.
+*       4/16/2001 : removed checking of return status of PV_BitstreamFlushBits
+***********************************************************CommentEnd********/
+
+int PV_VlcDecMCBPC_com_inter(BitstreamDecVideo *stream)
+{
+    uint code;
+
+    BitstreamShowBits16(stream, 9, &code);
+
+    if (code == 0)
+    {
+        return VLC_CODE_ERROR;
+    }
+    else if (code >= 256)
+    {
+        PV_BitstreamFlushBits(stream, 1);
+        return 0;
+    }
+
+    PV_BitstreamFlushBits(stream, PV_MCBPCtab[code].len);
+    return PV_MCBPCtab[code].val;
+}
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+int PV_VlcDecMCBPC_com_inter_H263(BitstreamDecVideo *stream)
+{
+    uint code;
+
+    BitstreamShow13Bits(stream, &code);
+
+    if (code == 0)
+    {
+        return VLC_CODE_ERROR;
+    }
+    else if (code >= 4096)
+    {
+        PV_BitstreamFlushBits(stream, 1);
+        return 0;
+    }
+    if (code >= 16)
+    {
+        PV_BitstreamFlushBits(stream, PV_MCBPCtab[code >> 4].len);
+        return PV_MCBPCtab[code >> 4].val;
+    }
+    else
+    {
+        PV_BitstreamFlushBits(stream, PV_MCBPCtab1[code - 8].len);
+        return PV_MCBPCtab1[code - 8].val;
+    }
+}
+#endif
+/***********************************************************CommentBegin******
+*       3/30/2000 : initial modification to the new PV-Decoder Lib
+*                           format and the change of error-handling method.
+*       4/16/2001 : removed status checking for PV_BitstreamFlushBits
+***********************************************************CommentEnd********/
+
+int PV_VlcDecCBPY(BitstreamDecVideo *stream, int intra)
+{
+    int CBPY = 0;
+    uint code;
+
+    BitstreamShowBits16(stream, 6, &code);
+
+
+    if (code < 2)
+    {
+        return -1;
+    }
+    else if (code >= 48)
+    {
+        PV_BitstreamFlushBits(stream, 2);
+        CBPY = 15;
+    }
+    else
+    {
+        PV_BitstreamFlushBits(stream, PV_CBPYtab[code].len);
+        CBPY = PV_CBPYtab[code].val;
+    }
+
+    if (intra == 0) CBPY = 15 - CBPY;
+    CBPY = CBPY & 15;
+    return CBPY;
+}
+
+
+/***********************************************************CommentBegin******
+*       3/31/2000 : initial modification to the new PV-Decoder Lib format.
+*
+*       8/23/2000 : optimize the function by removing unnecessary BitstreamShowBits()
+*                       function calls.
+*
+*       9/6/2000 : change the API to check for end-of-buffer for proper
+*                           termination of decoding process.
+***********************************************************CommentEnd********/
+PV_STATUS PV_VlcDecIntraDCPredSize(BitstreamDecVideo *stream, int compnum, uint *DC_size)
+{
+    PV_STATUS status = PV_FAIL;      /*  07/09/01 */
+    uint  code;
+
+    *DC_size = 0;
+    if (compnum < 4)  /* luminance block */
+    {
+
+        BitstreamShowBits16(stream, 11, &code);
+
+        if (code == 1)
+        {
+            *DC_size = 12;
+            PV_BitstreamFlushBits(stream, 11);
+            return PV_SUCCESS;
+        }
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 11;
+            PV_BitstreamFlushBits(stream, 10);
+            return PV_SUCCESS;
+        }
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 10;
+            PV_BitstreamFlushBits(stream, 9);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 9;
+            PV_BitstreamFlushBits(stream, 8);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 8;
+            PV_BitstreamFlushBits(stream, 7);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 7;
+            PV_BitstreamFlushBits(stream, 6);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 6;
+            PV_BitstreamFlushBits(stream, 5);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 5;
+            PV_BitstreamFlushBits(stream, 4);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 4;
+            PV_BitstreamFlushBits(stream, 3);
+            return PV_SUCCESS;
+        }
+        else if (code == 2)
+        {
+            *DC_size = 3;
+            PV_BitstreamFlushBits(stream, 3);
+            return PV_SUCCESS;
+        }
+        else if (code == 3)
+        {
+            *DC_size = 0;
+            PV_BitstreamFlushBits(stream, 3);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 2)
+        {
+            *DC_size = 2;
+            PV_BitstreamFlushBits(stream, 2);
+            return PV_SUCCESS;
+        }
+        else if (code == 3)
+        {
+            *DC_size = 1;
+            PV_BitstreamFlushBits(stream, 2);
+            return PV_SUCCESS;
+        }
+    }
+    else /* chrominance block */
+    {
+
+        BitstreamShow13Bits(stream, &code);
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 12;
+            PV_BitstreamFlushBits(stream, 12);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 11;
+            PV_BitstreamFlushBits(stream, 11);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 10;
+            PV_BitstreamFlushBits(stream, 10);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 9;
+            PV_BitstreamFlushBits(stream, 9);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 8;
+            PV_BitstreamFlushBits(stream, 8);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 7;
+            PV_BitstreamFlushBits(stream, 7);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 6;
+            PV_BitstreamFlushBits(stream, 6);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 5;
+            PV_BitstreamFlushBits(stream, 5);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 4;
+            PV_BitstreamFlushBits(stream, 4);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        if (code == 1)
+        {
+            *DC_size = 3;
+            PV_BitstreamFlushBits(stream, 3);
+            return PV_SUCCESS;
+        }
+
+        code >>= 1;
+        {
+            *DC_size = (int)(3 - code);
+            PV_BitstreamFlushBits(stream, 2);
+            return PV_SUCCESS;
+        }
+    }
+
+    return status;
+}
+
+/***********************************************************CommentBegin******
+*
+*
+*       3/30/2000 : initial modification to the new PV-Decoder Lib
+*                           format and the change of error-handling method.
+*
+***********************************************************CommentEnd********/
+
+
+
+PV_STATUS VlcDecTCOEFIntra(BitstreamDecVideo *stream, Tcoef *pTcoef)
+{
+    uint code;
+    const VLCtab2 *tab;
+
+    BitstreamShow13Bits(stream, &code);
+
+    /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFIntra */
+    /*  if(GetTcoeffIntra(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
+    if (code >= 1024)
+    {
+        tab = &PV_DCT3Dtab3[(code >> 6) - 16];
+    }
+    else
+    {
+        if (code >= 256)
+        {
+            tab = &PV_DCT3Dtab4[(code >> 3) - 32];
+        }
+        else
+        {
+            if (code >= 16)
+            {
+                tab = &PV_DCT3Dtab5[(code>>1) - 8];
+            }
+            else
+            {
+                return PV_FAIL;
+            }
+        }
+    }
+
+    PV_BitstreamFlushBits(stream, tab->len + 1);
+    pTcoef->sign = (code >> (12 - tab->len)) & 1;
+    pTcoef->run = (uint) tab->run; //(tab->val >> 8) & 255;
+    pTcoef->level = (int) tab->level; //tab->val & 255;
+    pTcoef->last = (uint) tab->last; //(tab->val >> 16) & 1;
+
+
+    /* the following is modified for 3-mode escape -- boon */
+    if (tab->level != 0xFF)
+    {
+        return PV_SUCCESS;
+    }
+
+    //if (((tab->run<<8)|(tab->level)|(tab->last<<16)) == VLC_ESCAPE_CODE)
+
+    if (!pTcoef->sign)
+    {
+        /* first escape mode. level is offset */
+        BitstreamShow13Bits(stream, &code);
+
+        /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFIntra */
+        /*          if(GetTcoeffIntra(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
+        if (code >= 1024)
+        {
+            tab = &PV_DCT3Dtab3[(code >> 6) - 16];
+        }
+        else
+        {
+            if (code >= 256)
+            {
+                tab = &PV_DCT3Dtab4[(code >> 3) - 32];
+            }
+            else
+            {
+                if (code >= 16)
+                {
+                    tab = &PV_DCT3Dtab5[(code>>1) - 8];
+                }
+                else
+                {
+                    return PV_FAIL;
+                }
+            }
+        }
+
+        PV_BitstreamFlushBits(stream, tab->len + 1);
+
+        /* sign bit */
+        pTcoef->sign = (code >> (12 - tab->len)) & 1;
+        pTcoef->run = (uint)tab->run; //(tab->val >> 8) & 255;
+        pTcoef->level = (int)tab->level; //tab->val & 255;
+        pTcoef->last = (uint)tab->last; //(tab->val >> 16) & 1;
+
+
+        /* need to add back the max level */
+        if ((pTcoef->last == 0 && pTcoef->run > 14) || (pTcoef->last == 1 && pTcoef->run > 20))
+        {
+            return PV_FAIL;
+        }
+        pTcoef->level = pTcoef->level + intra_max_level[pTcoef->last][pTcoef->run];
+
+
+    }
+    else
+    {
+        uint run_offset;
+        run_offset = BitstreamRead1Bits_INLINE(stream);
+
+        if (!run_offset)
+        {
+            /* second escape mode. run is offset */
+            BitstreamShow13Bits(stream, &code);
+
+            /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFIntra */
+            /*              if(GetTcoeffIntra(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
+            if (code >= 1024)
+            {
+                tab = &PV_DCT3Dtab3[(code >> 6) - 16];
+            }
+            else
+            {
+                if (code >= 256)
+                {
+                    tab = &PV_DCT3Dtab4[(code >> 3) - 32];
+                }
+                else
+                {
+                    if (code >= 16)
+                    {
+                        tab = &PV_DCT3Dtab5[(code>>1) - 8];
+                    }
+                    else
+                    {
+                        return PV_FAIL;
+                    }
+                }
+            }
+
+            PV_BitstreamFlushBits(stream, tab->len + 1);
+            /* sign bit */
+            pTcoef->sign = (code >> (12 - tab->len)) & 1;
+            pTcoef->run = (uint)tab->run; //(tab->val >> 8) & 255;
+            pTcoef->level = (int)tab->level; //tab->val & 255;
+            pTcoef->last = (uint)tab->last; //(tab->val >> 16) & 1;
+
+
+
+            /* need to add back the max run */
+            if (pTcoef->last)
+            {
+                if (pTcoef->level > 8)
+                {
+                    return PV_FAIL;
+                }
+                pTcoef->run = pTcoef->run + intra_max_run1[pTcoef->level] + 1;
+            }
+            else
+            {
+                if (pTcoef->level > 27)
+                {
+                    return PV_FAIL;
+                }
+                pTcoef->run = pTcoef->run + intra_max_run0[pTcoef->level] + 1;
+            }
+
+
+        }
+        else
+        {
+
+            code = BitstreamReadBits16_INLINE(stream, 8);
+            pTcoef->last = code >> 7;
+            pTcoef->run = (code >> 1) & 0x3F;
+            pTcoef->level = (int)(BitstreamReadBits16_INLINE(stream, 13) >> 1);
+
+            if (pTcoef->level >= 2048)
+            {
+                pTcoef->sign = 1;
+                pTcoef->level = 4096 - pTcoef->level;
+            }
+            else
+            {
+                pTcoef->sign = 0;
+            }
+        } /* flc */
+    }
+
+    return PV_SUCCESS;
+
+} /* VlcDecTCOEFIntra */
+
+PV_STATUS VlcDecTCOEFInter(BitstreamDecVideo *stream, Tcoef *pTcoef)
+{
+    uint code;
+    const VLCtab2 *tab;
+
+    BitstreamShow13Bits(stream, &code);
+
+    /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFInter */
+    /*  if(GetTcoeffInter(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
+    if (code >= 1024)
+    {
+        tab = &PV_DCT3Dtab0[(code >> 6) - 16];
+    }
+    else
+    {
+        if (code >= 256)
+        {
+            tab = &PV_DCT3Dtab1[(code >> 3) - 32];
+        }
+        else
+        {
+            if (code >= 16)
+            {
+                tab = &PV_DCT3Dtab2[(code>>1) - 8];
+            }
+            else
+            {
+                return PV_FAIL;
+            }
+        }
+    }
+    PV_BitstreamFlushBits(stream, tab->len + 1);
+    pTcoef->sign = (code >> (12 - tab->len)) & 1;
+    pTcoef->run = (uint)tab->run;     //(tab->val >> 4) & 255;
+    pTcoef->level = (int)tab->level; //tab->val & 15;
+    pTcoef->last = (uint)tab->last;   //(tab->val >> 12) & 1;
+
+    /* the following is modified for 3-mode escape -- boon */
+    if (tab->run != 0xBF)
+    {
+        return PV_SUCCESS;
+    }
+    //if (((tab->run<<4)|(tab->level)|(tab->last<<12)) == VLC_ESCAPE_CODE)
+
+
+    if (!pTcoef->sign)
+    {
+        /* first escape mode. level is offset */
+        BitstreamShow13Bits(stream, &code);
+
+        /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFInter */
+        /*          if(GetTcoeffInter(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
+        if (code >= 1024)
+        {
+            tab = &PV_DCT3Dtab0[(code >> 6) - 16];
+        }
+        else
+        {
+            if (code >= 256)
+            {
+                tab = &PV_DCT3Dtab1[(code >> 3) - 32];
+            }
+            else
+            {
+                if (code >= 16)
+                {
+                    tab = &PV_DCT3Dtab2[(code>>1) - 8];
+                }
+                else
+                {
+                    return PV_FAIL;
+                }
+            }
+        }
+        PV_BitstreamFlushBits(stream, tab->len + 1);
+        pTcoef->sign = (code >> (12 - tab->len)) & 1;
+        pTcoef->run = (uint)tab->run;     //(tab->val >> 4) & 255;
+        pTcoef->level = (int)tab->level; //tab->val & 15;
+        pTcoef->last = (uint)tab->last;   //(tab->val >> 12) & 1;
+
+        /* need to add back the max level */
+        if ((pTcoef->last == 0 && pTcoef->run > 26) || (pTcoef->last == 1 && pTcoef->run > 40))
+        {
+            return PV_FAIL;
+        }
+        pTcoef->level = pTcoef->level + inter_max_level[pTcoef->last][pTcoef->run];
+    }
+    else
+    {
+        uint run_offset;
+        run_offset = BitstreamRead1Bits_INLINE(stream);
+
+        if (!run_offset)
+        {
+            /* second escape mode. run is offset */
+            BitstreamShow13Bits(stream, &code);
+
+            /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFInter */
+            /*if(GetTcoeffInter(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
+            if (code >= 1024)
+            {
+                tab = &PV_DCT3Dtab0[(code >> 6) - 16];
+            }
+            else
+            {
+                if (code >= 256)
+                {
+                    tab = &PV_DCT3Dtab1[(code >> 3) - 32];
+                }
+                else
+                {
+                    if (code >= 16)
+                    {
+                        tab = &PV_DCT3Dtab2[(code>>1) - 8];
+                    }
+                    else
+                    {
+                        return PV_FAIL;
+                    }
+                }
+            }
+            PV_BitstreamFlushBits(stream, tab->len + 1);
+            pTcoef->sign = (code >> (12 - tab->len)) & 1;
+            pTcoef->run = (uint)tab->run;     //(tab->val >> 4) & 255;
+            pTcoef->level = (int)tab->level; //tab->val & 15;
+            pTcoef->last = (uint)tab->last;   //(tab->val >> 12) & 1;
+
+            /* need to add back the max run */
+            if (pTcoef->last)
+            {
+                if (pTcoef->level > 3)
+                {
+                    return PV_FAIL;
+                }
+                pTcoef->run = pTcoef->run + inter_max_run1[pTcoef->level] + 1;
+            }
+            else
+            {
+                if (pTcoef->level > 12)
+                {
+                    return PV_FAIL;
+                }
+                pTcoef->run = pTcoef->run + inter_max_run0[pTcoef->level] + 1;
+            }
+        }
+        else
+        {
+
+            code = BitstreamReadBits16_INLINE(stream, 8);
+            pTcoef->last = code >> 7;
+            pTcoef->run = (code >> 1) & 0x3F;
+            pTcoef->level = (int)(BitstreamReadBits16_INLINE(stream, 13) >> 1);
+
+
+
+            if (pTcoef->level >= 2048)
+            {
+                pTcoef->sign = 1;
+                pTcoef->level = 4096 - pTcoef->level;
+            }
+            else
+            {
+                pTcoef->sign = 0;
+            }
+        } /* flc */
+    }
+
+    return PV_SUCCESS;
+
+} /* VlcDecTCOEFInter */
+
+/*=======================================================
+    Function:   VlcDecTCOEFShortHeader()
+    Date    :   04/27/99
+    Purpose :   New function used in decoding of video planes
+                with short header
+    Modified:   05/23/2000
+                for new decoder structure.
+=========================================================*/
+PV_STATUS VlcDecTCOEFShortHeader(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra*/)
+{
+    uint code;
+    const VLCtab2 *tab;
+
+    BitstreamShow13Bits(stream, &code);
+
+    /*intra = 0;*/
+
+    if (code >= 1024) tab = &PV_DCT3Dtab0[(code >> 6) - 16];
+    else
+    {
+        if (code >= 256) tab = &PV_DCT3Dtab1[(code >> 3) - 32];
+        else
+        {
+            if (code >= 16) tab = &PV_DCT3Dtab2[(code>>1) - 8];
+            else return PV_FAIL;
+        }
+    }
+
+    PV_BitstreamFlushBits(stream, tab->len + 1);
+    pTcoef->sign = (code >> (12 - tab->len)) & 1;
+    pTcoef->run = (uint)tab->run;//(tab->val >> 4) & 255;
+    pTcoef->level = (int)tab->level;//tab->val & 15;
+    pTcoef->last = (uint)tab->last;//(tab->val >> 12) & 1;
+
+    /* the following is modified for 3-mode escape -- boon */
+    if (((tab->run << 4) | (tab->level) | (tab->last << 12)) != VLC_ESCAPE_CODE)    /* ESCAPE */
+    {
+        return PV_SUCCESS;
+    }
+
+
+    /* escape mode 4 - H.263 type */
+    pTcoef->last = pTcoef->sign; /* Last */
+    pTcoef->run = BitstreamReadBits16_INLINE(stream, 6); /* Run */
+    pTcoef->level = (int) BitstreamReadBits16_INLINE(stream, 8); /* Level */
+
+    if (pTcoef->level == 0 || pTcoef->level == 128)
+    {
+        return PV_FAIL;
+    }
+
+    if (pTcoef->level > 128)
+    {
+        pTcoef->sign = 1;
+        pTcoef->level = 256 - pTcoef->level;
+    }
+    else
+    {
+        pTcoef->sign = 0;
+    }
+
+
+
+    return PV_SUCCESS;
+
+}   /* VlcDecTCOEFShortHeader */
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+PV_STATUS VlcDecTCOEFShortHeader_AnnexI(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra*/)
+{
+    uint code;
+    const VLCtab2 *tab;
+
+    BitstreamShow13Bits(stream, &code);
+
+    /*intra = 0;*/
+
+    if (code >= 1024) tab = &PV_DCT3Dtab6[(code >> 6) - 16];
+    else
+    {
+        if (code >= 256) tab = &PV_DCT3Dtab7[(code >> 3) - 32];
+        else
+        {
+            if (code >= 16) tab = &PV_DCT3Dtab8[(code>>1) - 8];
+            else return PV_FAIL;
+        }
+    }
+
+    PV_BitstreamFlushBits(stream, tab->len + 1);
+    pTcoef->sign = (code >> (12 - tab->len)) & 1;
+    pTcoef->run = (uint)tab->run;//(tab->val >> 4) & 255;
+    pTcoef->level = (int)tab->level;//tab->val & 15;
+    pTcoef->last = (uint)tab->last;//(tab->val >> 12) & 1;
+
+    /* the following is modified for 3-mode escape -- boon */
+    if (((tab->run << 6) | (tab->level) | (tab->last << 12)) != VLC_ESCAPE_CODE)    /* ESCAPE */
+    {
+        return PV_SUCCESS;
+    }
+    /* escape mode 4 - H.263 type */
+    pTcoef->last = pTcoef->sign; /* Last */
+    pTcoef->run = BitstreamReadBits16(stream, 6); /* Run */
+    pTcoef->level = (int) BitstreamReadBits16(stream, 8); /* Level */
+
+    if (pTcoef->level == 0 || pTcoef->level == 128)
+    {
+        return PV_FAIL;
+    }
+
+
+    if (pTcoef->level > 128)
+    {
+        pTcoef->sign = 1;
+        pTcoef->level = 256 - pTcoef->level;
+    }
+    else pTcoef->sign = 0;
+
+
+
+    return PV_SUCCESS;
+
+}   /* VlcDecTCOEFShortHeader_AnnexI */
+
+PV_STATUS VlcDecTCOEFShortHeader_AnnexT(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra*/)
+{
+    uint code;
+    const VLCtab2 *tab;
+
+    BitstreamShow13Bits(stream, &code);
+
+    /*intra = 0;*/
+
+    if (code >= 1024) tab = &PV_DCT3Dtab0[(code >> 6) - 16];
+    else
+    {
+        if (code >= 256) tab = &PV_DCT3Dtab1[(code >> 3) - 32];
+        else
+        {
+            if (code >= 16) tab = &PV_DCT3Dtab2[(code>>1) - 8];
+            else return PV_FAIL;
+        }
+    }
+
+    PV_BitstreamFlushBits(stream, tab->len + 1);
+    pTcoef->sign = (code >> (12 - tab->len)) & 1;
+    pTcoef->run = (uint)tab->run;//(tab->val >> 4) & 255;
+    pTcoef->level = (int)tab->level;//tab->val & 15;
+    pTcoef->last = (uint)tab->last;//(tab->val >> 12) & 1;
+
+    /* the following is modified for 3-mode escape --  */
+    if (((tab->run << 4) | (tab->level) | (tab->last << 12)) != VLC_ESCAPE_CODE)    /* ESCAPE */
+    {
+        return PV_SUCCESS;
+    }
+    /* escape mode 4 - H.263 type */
+    pTcoef->last = pTcoef->sign; /* Last */
+    pTcoef->run = BitstreamReadBits16(stream, 6); /* Run */
+    pTcoef->level = (int) BitstreamReadBits16(stream, 8); /* Level */
+
+    if (pTcoef->level == 0)
+    {
+        return PV_FAIL;
+    }
+
+    if (pTcoef->level >= 128)
+    {
+        pTcoef->sign = 1;
+        pTcoef->level = 256 - pTcoef->level;
+    }
+    else
+    {
+        pTcoef->sign = 0;
+    }
+
+    if (pTcoef->level == 128)
+    {
+        code = BitstreamReadBits16(stream, 11);        /* ANNEX_T */
+
+        code = (code >> 6 & 0x1F) | (code << 5 & 0x7ff);
+        if (code > 1024)
+        {
+            pTcoef->sign = 1;
+            pTcoef->level = (2048 - code);
+        }
+        else
+        {
+            pTcoef->sign = 0;
+            pTcoef->level = code;
+        }
+    }
+
+    return PV_SUCCESS;
+
+}   /* VlcDecTCOEFShortHeader */
+
+
+PV_STATUS VlcDecTCOEFShortHeader_AnnexIT(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra*/)
+{
+    uint code;
+    const VLCtab2 *tab;
+
+    BitstreamShow13Bits(stream, &code);
+
+    /*intra = 0;*/
+
+    if (code >= 1024) tab = &PV_DCT3Dtab6[(code >> 6) - 16];
+    else
+    {
+        if (code >= 256) tab = &PV_DCT3Dtab7[(code >> 3) - 32];
+        else
+        {
+            if (code >= 16) tab = &PV_DCT3Dtab8[(code>>1) - 8];
+            else return PV_FAIL;
+        }
+    }
+
+    PV_BitstreamFlushBits(stream, tab->len + 1);
+    pTcoef->sign = (code >> (12 - tab->len)) & 1;
+    pTcoef->run = (uint)tab->run;//(tab->val >> 4) & 255;
+    pTcoef->level = (int)tab->level;//tab->val & 15;
+    pTcoef->last = (uint)tab->last;//(tab->val >> 12) & 1;
+
+    /* the following is modified for 3-mode escape --  */
+    if (((tab->run << 6) | (tab->level) | (tab->last << 12)) != VLC_ESCAPE_CODE)    /* ESCAPE */
+    {
+        return PV_SUCCESS;
+    }
+    /* escape mode 4 - H.263 type */
+    pTcoef->last = pTcoef->sign; /* Last */
+    pTcoef->run = BitstreamReadBits16(stream, 6); /* Run */
+    pTcoef->level = (int) BitstreamReadBits16(stream, 8); /* Level */
+
+    if (pTcoef->level == 0)
+    {
+        return PV_FAIL;
+    }
+
+    if (pTcoef->level >= 128)
+    {
+        pTcoef->sign = 1;
+        pTcoef->level = 256 - pTcoef->level;
+    }
+    else
+    {
+        pTcoef->sign = 0;
+    }
+
+    if (pTcoef->level == 128)
+    {
+        code = BitstreamReadBits16(stream, 11);        /* ANNEX_T */
+
+        code = (code >> 6 & 0x1F) | (code << 5 & 0x7ff);
+        if (code > 1024)
+        {
+            pTcoef->sign = 1;
+            pTcoef->level = (2048 - code);
+        }
+        else
+        {
+            pTcoef->sign = 0;
+            pTcoef->level = code;
+        }
+    }
+
+
+    return PV_SUCCESS;
+
+}   /* VlcDecTCOEFShortHeader_AnnexI */
+#endif
+/***********************************************************CommentBegin******
+*       3/30/2000 : initial modification to the new PV-Decoder Lib
+*                           format and the change of error-handling method.
+*                           The coefficient is now returned thru a pre-
+*                           initialized parameters for speedup.
+*
+***********************************************************CommentEnd********/
+
+
+PV_STATUS RvlcDecTCOEFInter(BitstreamDecVideo *stream, Tcoef *pTcoef)
+{
+    uint code, mask;
+    const VLCtab2 *tab2;
+    int count, len, num[2] = {0, 0} /*  01/30/01 */;
+
+    mask = 0x4000;      /* mask  100000000000000   */
+    BitstreamShow15Bits(stream, &code);   /*  03/07/01 */
+
+    len = 1;
+
+    //  09/20/99 Escape mode
+    /// Bitstream Exchange
+    if (code < 2048)
+    {
+        PV_BitstreamFlushBits(stream, 5);
+        pTcoef->last = BitstreamRead1Bits_INLINE(stream);
+        pTcoef->run = BitstreamReadBits16_INLINE(stream, 6);
+        //  09/20/99 New marker bit
+        PV_BitstreamFlushBits(stream, 1);
+        //  09/20/99 The length for LEVEL used to be 7 in the old version
+        pTcoef->level = (int)(BitstreamReadBits16_INLINE(stream, 12) >> 1);
+        //  09/20/99 Another new marker bit
+//      PV_BitstreamFlushBitsCheck(stream, 1);
+        pTcoef->sign = BitstreamReadBits16_INLINE(stream, 5) & 0x1;  /* fix   3/13/01  */
+        return PV_SUCCESS;
+    }
+
+    if (code & mask)
+    {
+        count = 1;
+        while (mask && count > 0)       /* fix  3/28/01  */
+        {
+            mask = mask >> 1;
+            if (code & mask)
+                count--;
+            else
+                num[0]++; /* number of zeros in the middle */
+            len++;
+        }
+    }
+    else
+    {
+        count = 2;
+        while (mask && count > 0)           /* fix  3/28/01  */
+        {
+            mask = mask >> 1;
+            if (!(code & mask))
+                count--;
+            else
+                num[count-1]++; /* number of ones in the middle */
+            len++;
+        }
+    }
+
+    code = code & 0x7fff;
+    code = code >> (15 - (len + 1));
+
+    /*  1/30/01, add fast decoding algorithm here */
+    /* code is in two forms : 0xxxx0xxx00 or 0xxx0xxx01
+                         num[1] and num[0] x
+                        or  : 1xxxxx10 or 1xxxxx11
+                                num[0]  x      */
+
+    /* len+1 is the length of the above */
+
+    if (num[1] > 10 || num[0] > 11) /* invalid RVLC code */
+        return PV_FAIL;
+
+    if (code&(1 << len))
+        tab2 = RvlcDCTtabInter + 146 + (num[0] << 1) + (code & 1);
+    else
+        tab2 = RvlcDCTtabInter + ptrRvlcTab[num[1]] + (num[0] << 1) + (code & 1);
+
+    PV_BitstreamFlushBits(stream, (int) tab2->len);
+    pTcoef->run = (uint)tab2->run;//(tab->val >> 8) & 255;
+    pTcoef->level = (int)tab2->level;//tab->val & 255;
+    pTcoef->last = (uint)tab2->last;//(tab->val >> 16) & 1;
+
+    pTcoef->sign = BitstreamRead1Bits_INLINE(stream);
+    return PV_SUCCESS;
+}               /* RvlcDecTCOEFInter */
+
+PV_STATUS RvlcDecTCOEFIntra(BitstreamDecVideo *stream, Tcoef *pTcoef)
+{
+    uint code, mask;
+    const VLCtab2 *tab2;
+    int count, len, num[2] = {0, 0} /*  01/30/01 */;
+
+    mask = 0x4000;      /* mask  100000000000000   */
+    BitstreamShow15Bits(stream, &code);
+
+    len = 1;
+
+    //  09/20/99 Escape mode
+    /// Bitstream Exchange
+    if (code < 2048)
+    {
+        PV_BitstreamFlushBits(stream, 5);
+        pTcoef->last = BitstreamRead1Bits_INLINE(stream);
+        pTcoef->run = BitstreamReadBits16_INLINE(stream, 6);
+        //  09/20/99 New marker bit
+        PV_BitstreamFlushBits(stream, 1);
+        //  09/20/99 The length for LEVEL used to be 7 in the old version
+        pTcoef->level = (int)(BitstreamReadBits16_INLINE(stream, 12) >> 1);
+        //  09/20/99 Another new marker bit
+//      PV_BitstreamFlushBitsCheck(stream, 1);
+        pTcoef->sign = BitstreamReadBits16_INLINE(stream, 5) & 0x1; /* fix   03/13/01 */
+        return PV_SUCCESS;
+    }
+
+    if (code & mask)
+    {
+        count = 1;
+        while (mask && count > 0)                          /* fix  03/28/01 */
+        {
+            mask = mask >> 1;
+            if (code & mask)
+                count--;
+            else
+                num[0]++; /* number of zeros in the middle */
+            len++;
+        }
+    }
+    else
+    {
+        count = 2;
+        while (mask && count > 0)              /* fix  03/28/01 */
+        {
+            mask = mask >> 1;
+            if (!(code & mask))
+                count--;
+            else
+                num[count-1]++; /* number of ones in the middle */
+            len++;
+        }
+    }
+
+    code = code & 0x7fff;
+    code = code >> (15 - (len + 1));
+
+    /*  1/30/01, add fast decoding algorithm here */
+    /* code is in two forms : 0xxxx0xxx00 or 0xxx0xxx01
+                         num[1] and num[0] x
+                        or  : 1xxxxx10 or 1xxxxx11
+                                num[0]  x      */
+
+    /* len+1 is the length of the above */
+
+    if (num[1] > 10 || num[0] > 11) /* invalid RVLC code */
+        return PV_FAIL;
+
+    if (code & (1 << len))
+        tab2 = RvlcDCTtabIntra + 146 + (num[0] << 1) + (code & 1);
+    else
+        tab2 = RvlcDCTtabIntra + ptrRvlcTab[num[1]] + (num[0] << 1) + (code & 1);
+
+    PV_BitstreamFlushBits(stream, (int) tab2->len);
+    pTcoef->run = (uint)tab2->run;//(tab->val >> 8) & 255;
+    pTcoef->level = (int)tab2->level;//tab->val & 255;
+    pTcoef->last = (uint)tab2->last;//(tab->val >> 16) & 1;
+
+    pTcoef->sign = BitstreamRead1Bits_INLINE(stream);
+    return PV_SUCCESS;
+}               /* RvlcDecTCOEFIntra */
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/vlc_decode.h b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_decode.h
new file mode 100644
index 0000000..a804606
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_decode.h
@@ -0,0 +1,122 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+/*
+-------------------------------------------------------------------
+                    MPEG-4 Simple Profile Video Decoder
+-------------------------------------------------------------------
+*
+* This software module was originally developed by
+*
+*   Paulo Nunes (IST / ACTS-MoMuSyS)
+*
+* in the course of development of the MPEG-4 Video (ISO/IEC 14496-2) standard.
+* This software module is an implementation of a part of one or more MPEG-4
+* Video (ISO/IEC 14496-2) tools as specified by the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* ISO/IEC gives users of the MPEG-4 Video (ISO/IEC 14496-2) standard free
+* license to this software module or modifications thereof for use in hardware
+* or software products claiming conformance to the MPEG-4 Video (ISO/IEC
+* 14496-2) standard.
+*
+* Those intending to use this software module in hardware or software products
+* are advised that its use may infringe existing patents. The original
+* developer of this software module and his/her company, the subsequent
+* editors and their companies, and ISO/IEC have no liability for use of this
+* software module or modifications thereof in an implementation. Copyright is
+* not released for non MPEG-4 Video (ISO/IEC 14496-2) Standard conforming
+* products.
+*
+* ACTS-MoMuSys partners retain full right to use the code for his/her own
+* purpose, assign or donate the code to a third party and to inhibit third
+* parties from using the code for non MPEG-4 Video (ISO/IEC 14496-2) Standard
+* conforming products. This copyright notice must be included in all copies or
+* derivative works.
+*
+* Copyright (c) 1996
+*
+*****************************************************************************/
+
+/***********************************************************HeaderBegin*******
+*
+* File: vlc_dec.h
+*
+* Author:   Paulo Nunes (IST) - Paulo.Nunes@lx.it.pt
+* Created:
+*
+* Description: This is the header file for the "vlcdec" module.
+*
+* Notes:
+*
+* Modified: 9-May-96 Paulo Nunes: Reformatted. New headers.
+*
+* ================= PacketVideo Modification ================================
+*
+*       3/30/00  : initial modification to the
+*                new PV-Decoder Lib format.
+*
+***********************************************************CommentEnd********/
+
+
+#ifndef _VLCDECODE_H_
+#define _VLCDECODE_H_
+
+#include "mp4lib_int.h"
+
+#define VLC_ERROR_DETECTED(x) ((x) < 0)
+#define VLC_IO_ERROR    -1
+#define VLC_CODE_ERROR  -2
+#define VLC_MB_STUFFING -4
+#define VLC_NO_LAST_BIT -5
+
+#define VLC_ESCAPE_CODE  7167
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+    PV_STATUS DecodeUserData(BitstreamDecVideo *stream);
+    PV_STATUS PV_GetMBvectors(VideoDecData *, uint mode);
+    PV_STATUS PV_DecodeMBVec(BitstreamDecVideo *stream, MOT *mv_x, MOT *mv_y, int f_code_f);
+    PV_STATUS PV_DeScaleMVD(int f_code, int residual, int vlc_code_mag,  MOT *vector);
+
+    PV_STATUS PV_VlcDecMV(BitstreamDecVideo *stream, int *mv);
+    int PV_VlcDecMCBPC_com_intra(BitstreamDecVideo *stream);
+    int PV_VlcDecMCBPC_com_inter(BitstreamDecVideo *stream);
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    int PV_VlcDecMCBPC_com_inter_H263(BitstreamDecVideo *stream);
+    PV_STATUS VlcDecTCOEFShortHeader_AnnexI(BitstreamDecVideo *stream, Tcoef *pTcoef);
+    PV_STATUS VlcDecTCOEFShortHeader_AnnexT(BitstreamDecVideo *stream, Tcoef *pTcoef); /* ANNEX_T */
+    PV_STATUS VlcDecTCOEFShortHeader_AnnexIT(BitstreamDecVideo *stream, Tcoef *pTcoef);
+#endif
+    int PV_VlcDecCBPY(BitstreamDecVideo *stream, int intra);
+
+    PV_STATUS VlcDecTCOEFIntra(BitstreamDecVideo *stream, Tcoef *pTcoef);
+    PV_STATUS VlcDecTCOEFInter(BitstreamDecVideo *stream, Tcoef *pTcoef);
+    PV_STATUS VlcDecTCOEFShortHeader(BitstreamDecVideo *stream, Tcoef *pTcoef);
+    PV_STATUS RvlcDecTCOEFIntra(BitstreamDecVideo *stream, Tcoef *pTcoef);
+    PV_STATUS RvlcDecTCOEFInter(BitstreamDecVideo *stream, Tcoef *pTcoef);
+    PV_STATUS PV_VlcDecIntraDCPredSize(BitstreamDecVideo *stream, int compnum, uint *DC_size);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus  */
+
+#endif
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/vlc_dequant.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_dequant.cpp
new file mode 100644
index 0000000..db13a48
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_dequant.cpp
@@ -0,0 +1,1152 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h"
+#include "vlc_decode.h"
+#include "zigzag.h"
+
+
+typedef PV_STATUS(*VlcDecFuncP)(BitstreamDecVideo *stream, Tcoef *pTcoef);
+static const uint8 AC_rowcol[64] = {    0, 0, 0, 0, 0, 0, 0, 0,
+                                        0, 1, 1, 1, 1, 1, 1, 1,
+                                        0, 1, 1, 1, 1, 1, 1, 1,
+                                        0, 1, 1, 1, 1, 1, 1, 1,
+                                        0, 1, 1, 1, 1, 1, 1, 1,
+                                        0, 1, 1, 1, 1, 1, 1, 1,
+                                        0, 1, 1, 1, 1, 1, 1, 1,
+                                        0, 1, 1, 1, 1, 1, 1, 1,
+                                   };
+static const uint8 mask[8] = /*  for fast bitmap */
+    {128, 64, 32, 16, 8, 4, 2, 1};
+
+
+
+/***********************************************************CommentBegin******
+*
+* -- VlcDequantMpegBlock -- Decodes the DCT coefficients of one 8x8 block and perform
+            dequantization using Mpeg mode.
+    Date:       08/08/2000
+
+    Modified:      3/21/01
+                Added pre IDCT clipping, new ACDC prediction structure, ACDC prediction clipping,
+                16-bit int case, removed multiple zigzaging
+******************************************************************************/
+
+#ifdef PV_SUPPORT_MAIN_PROFILE
+int VlcDequantMpegIntraBlock(void *vid, int comp, int switched,
+                             uint8 *bitmapcol, uint8 *bitmaprow)
+{
+    VideoDecData *video = (VideoDecData*) vid;
+    Vol *currVol = video->vol[video->currLayer];
+    BitstreamDecVideo *stream = video->bitstream;
+    int16 *datablock = video->mblock->block[comp]; /* 10/20/2000, assume it has been reset of all-zero !!!*/
+    int mbnum = video->mbnum;
+    uint CBP = video->headerInfo.CBP[mbnum];
+    int QP = video->QPMB[mbnum];
+    typeDCStore *DC = video->predDC + mbnum;
+    int x_pos = video->mbnum_col;
+    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
+    typeDCACStore *DCAC_col = video->predDCAC_col;
+    uint ACpred_flag = (uint) video->acPredFlag[mbnum];
+
+    /*** VLC *****/
+    int i, j, k;
+    Tcoef run_level;
+    int last, return_status;
+    VlcDecFuncP vlcDecCoeff;
+    int direction;
+    const int *inv_zigzag;
+    /*** Quantizer ****/
+    int dc_scaler;
+    int sum;
+    int *qmat;
+    int32 temp;
+
+    const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
+    const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
+
+    int16 *dcac_row, *dcac_col;
+
+    dcac_row = (*DCAC_row)[B_Xtab[comp]];
+    dcac_col = (*DCAC_col)[B_Ytab[comp]];
+
+
+    i = 1 - switched;
+
+#ifdef FAST_IDCT
+    *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+#endif
+
+
+    /* select which Huffman table to be used */
+    vlcDecCoeff = video->vlcDecCoeffIntra;
+
+    dc_scaler = (comp < 4) ? video->mblock->DCScalarLum : video->mblock->DCScalarChr;
+
+    /* enter the zero run decoding loop */
+    sum = 0;
+    qmat = currVol->iqmat;
+
+    /* perform only VLC decoding */
+    /* We cannot do DCACrecon before VLC decoding.  10/17/2000 */
+    doDCACPrediction(video, comp, datablock, &direction);
+    if (!ACpred_flag) direction = 0;
+    inv_zigzag = zigzag_inv + (ACpred_flag << 6) + (direction << 6);
+    if (CBP & (1 << (5 - comp)))
+    {
+        do
+        {
+            return_status = (*vlcDecCoeff)(stream, &run_level);
+            if (return_status != PV_SUCCESS)
+            {
+                last = 1;/*  11/1/2000 let it slips undetected, just like
+                         in original version */
+                i = VLC_ERROR;
+                ACpred_flag = 0;    /* no of coefficients should not get reset   03/07/2002 */
+                break;
+            }
+
+            i += run_level.run;
+            last = run_level.last;
+            if (i >= 64)
+            {
+                /*  i = NCOEFF_BLOCK; */    /*  11/1/00 */
+                ACpred_flag = 0;    /* no of coefficients should not get reset   03/07/2002 */
+                i = VLC_NO_LAST_BIT;
+                last = 1;
+                break;
+            }
+
+            k = inv_zigzag[i];
+
+            if (run_level.sign == 1)
+            {
+                datablock[k] -= run_level.level;
+            }
+            else
+            {
+                datablock[k] += run_level.level;
+            }
+
+            if (AC_rowcol[k])
+            {
+                temp = (int32)datablock[k] * qmat[k] * QP;
+                temp = (temp + (0x7 & (temp >> 31))) >> 3;
+                if (temp > 2047) temp = 2047;
+                else if (temp < -2048) temp = -2048;
+                datablock[k] = (int) temp;
+
+#ifdef FAST_IDCT
+                bitmapcol[k&0x7] |= mask[k>>3];
+#endif
+                sum ^= temp;
+            }
+
+            i++;
+        }
+        while (!last);
+
+    }
+    else
+    {
+        i = 1;       /*  04/26/01  needed for switched case */
+    }
+    ///// NEED TO DEQUANT THOSE PREDICTED AC COEFF
+    /* dequantize the rest of AC predicted coeff that haven't been dequant */
+    if (ACpred_flag)
+    {
+
+        i = NCOEFF_BLOCK; /* otherwise, FAST IDCT won't work correctly,  10/18/2000 */
+
+        if (!direction) /* check vertical */
+        {
+            dcac_row[0]  = datablock[1];
+            dcac_row[1]  = datablock[2];
+            dcac_row[2]  = datablock[3];
+            dcac_row[3]  = datablock[4];
+            dcac_row[4]  = datablock[5];
+            dcac_row[5]  = datablock[6];
+            dcac_row[6]  = datablock[7];
+
+            for (j = 0, k = 8; k < 64; k += 8, j++)
+            {
+                if (dcac_col[j] = datablock[k])
+                {     /* ACDC clipping  03/26/01 */
+                    if (datablock[k] > 2047) dcac_col[j] = 2047;
+                    else if (datablock[k] < -2048) dcac_col[j] = -2048;
+
+                    temp = (int32)dcac_col[j] * qmat[k] * QP;
+                    temp = (temp + (0x7 & (temp >> 31))) >> 3;  /*  03/26/01*/
+                    if (temp > 2047) temp = 2047;
+                    else if (temp < -2048) temp = -2048;
+                    datablock[k] = (int)temp;
+                    sum ^= temp; /*  7/5/01 */
+#ifdef FAST_IDCT
+                    bitmapcol[0] |= mask[k>>3];
+#endif
+
+                }
+            }
+            for (k = 1; k < 8; k++)
+            {
+                if (datablock[k])
+                {
+                    temp = (int32)datablock[k] * qmat[k] * QP;
+                    temp = (temp + (0x7 & (temp >> 31))) >> 3;  /*  03/26/01*/
+                    if (temp > 2047) temp = 2047;
+                    else if (temp < -2048) temp = -2048;
+                    datablock[k] = (int)temp;
+                    sum ^= temp; /*  7/5/01 */
+#ifdef FAST_IDCT
+                    bitmapcol[k] |= 128;
+#endif
+
+                }
+            }
+
+        }
+        else
+        {
+
+            dcac_col[0]  = datablock[8];
+            dcac_col[1]  = datablock[16];
+            dcac_col[2]  = datablock[24];
+            dcac_col[3]  = datablock[32];
+            dcac_col[4]  = datablock[40];
+            dcac_col[5]  = datablock[48];
+            dcac_col[6]  = datablock[56];
+
+
+            for (j = 0, k = 1; k < 8; k++, j++)
+            {
+                if (dcac_row[j] = datablock[k])
+                {     /* ACDC clipping  03/26/01 */
+                    if (datablock[k] > 2047) dcac_row[j] = 2047;
+                    else if (datablock[k] < -2048) dcac_row[j] = -2048;
+
+                    temp = (int32)dcac_row[j] * qmat[k] * QP;
+                    temp = (temp + (0x7 & (temp >> 31))) >> 3;  /*  03/26/01 */
+                    if (temp > 2047) temp = 2047;
+                    else if (temp < -2048) temp = -2048;
+                    datablock[k] = (int)temp;
+                    sum ^= temp;
+#ifdef FAST_IDCT
+                    bitmapcol[k] |= 128;
+#endif
+
+                }
+            }
+
+            for (k = 8; k < 64; k += 8)
+            {
+                if (datablock[k])
+                {
+                    temp = (int32)datablock[k] * qmat[k] * QP;
+                    temp = (temp + (0x7 & (temp >> 31))) >> 3;  /*  03/26/01 */
+                    if (temp > 2047) temp = 2047;
+                    else if (temp < -2048) temp = -2048;
+                    datablock[k] = (int)temp;
+                    sum ^= temp;
+#ifdef FAST_IDCT
+                    bitmapcol[0] |= mask[k>>3];
+#endif
+                }
+            }
+
+        }
+    }
+    else
+    {
+
+        /* Store the qcoeff-values needed later for prediction */
+
+        dcac_row[0] = datablock[1];                /*  ACDC, no need for clipping */
+        dcac_row[1] = datablock[2];
+        dcac_row[2] = datablock[3];
+        dcac_row[3] = datablock[4];
+        dcac_row[4] = datablock[5];
+        dcac_row[5] = datablock[6];
+        dcac_row[6] = datablock[7];
+
+        dcac_col[0] = datablock[8];
+        dcac_col[1] = datablock[16];
+        dcac_col[2] = datablock[24];
+        dcac_col[3] = datablock[32];
+        dcac_col[4] = datablock[40];
+        dcac_col[5] = datablock[48];
+        dcac_col[6] = datablock[56];
+
+        for (k = 1; k < 8; k++)
+        {
+            if (datablock[k])
+            {
+                temp = (int32)datablock[k] * qmat[k] * QP;
+                temp = (temp + (0x7 & (temp >> 31))) >> 3;  /*  03/26/01*/
+                if (temp > 2047) temp = 2047;
+                else if (temp < -2048) temp = -2048;
+                datablock[k] = (int)temp;
+                sum ^= temp; /*  7/5/01 */
+#ifdef FAST_IDCT
+                bitmapcol[k] |= 128;
+#endif
+
+            }
+        }
+        for (k = 8; k < 64; k += 8)
+        {
+            if (datablock[k])
+            {
+                temp = (int32)datablock[k] * qmat[k] * QP;
+                temp = (temp + (0x7 & (temp >> 31))) >> 3;  /*  03/26/01 */
+                if (temp > 2047) temp = 2047;
+                else if (temp < -2048) temp = -2048;
+                datablock[k] = (int)temp;
+                sum ^= temp;
+#ifdef FAST_IDCT
+                bitmapcol[0] |= mask[k>>3];
+#endif
+            }
+        }
+
+    }
+
+
+
+    if (datablock[0])
+    {
+        temp = (int32)datablock[0] * dc_scaler;
+        if (temp > 2047) temp = 2047;            /*  03/14/01 */
+        else if (temp < -2048)  temp = -2048;
+        datablock[0] = (int)temp;
+        sum ^= temp;
+#ifdef FAST_IDCT
+        bitmapcol[0] |= 128;
+#endif
+    }
+
+    if ((sum & 1) == 0)
+    {
+        datablock[63] = datablock[63] ^ 0x1;
+#ifdef FAST_IDCT   /*  7/5/01, need to update bitmap */
+        if (datablock[63])
+            bitmapcol[7] |= 1;
+#endif
+        i = (-64 & i) | NCOEFF_BLOCK;   /*  if i > -1 then i is set to NCOEFF_BLOCK */
+    }
+
+
+#ifdef FAST_IDCT
+    if (i > 10)
+    {
+        for (k = 1; k < 4; k++)
+        {
+            if (bitmapcol[k] != 0)
+            {
+                (*bitmaprow) |= mask[k];
+            }
+        }
+    }
+#endif
+
+    /* Store the qcoeff-values needed later for prediction */
+    (*DC)[comp] = datablock[0];
+    return i;
+
+}
+
+
+/***********************************************************CommentBegin******
+*
+* -- VlcDequantMpegInterBlock -- Decodes the DCT coefficients of one 8x8 block and perform
+            dequantization using Mpeg mode for INTER block.
+    Date:       08/08/2000
+    Modified:              3/21/01
+                clean up, added clipping, 16-bit int case, new ACDC prediction
+******************************************************************************/
+
+
+int VlcDequantMpegInterBlock(void *vid, int comp,
+                             uint8 *bitmapcol, uint8 *bitmaprow)
+{
+    VideoDecData *video = (VideoDecData*) vid;
+    BitstreamDecVideo *stream = video->bitstream;
+    Vol *currVol = video->vol[video->currLayer];
+    int16 *datablock = video->mblock->block[comp]; /* 10/20/2000, assume it has been reset of all-zero !!!*/
+    int mbnum = video->mbnum;
+    int QP = video->QPMB[mbnum];
+    /*** VLC *****/
+    int i, k;
+    Tcoef run_level;
+    int last, return_status;
+    VlcDecFuncP vlcDecCoeff;
+
+    /*** Quantizer ****/
+    int sum;
+    int *qmat;
+
+    int32 temp;
+
+    i = 0 ;
+
+#ifdef FAST_IDCT
+    *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+#endif
+
+    /* select which Huffman table to be used */
+    vlcDecCoeff = video->vlcDecCoeffInter;
+
+    /* enter the zero run decoding loop */
+    sum = 0;
+    qmat = currVol->niqmat;
+    do
+    {
+        return_status = (*vlcDecCoeff)(stream, &run_level);
+        if (return_status != PV_SUCCESS)
+        {
+            last = 1;/*  11/1/2000 let it slips undetected, just like
+                     in original version */
+            i = VLC_ERROR;
+            sum = 1;    /* no of coefficients should not get reset   03/07/2002 */
+            break;
+        }
+
+        i += run_level.run;
+        last = run_level.last;
+        if (i >= 64)
+        {
+            /*  i = NCOEFF_BLOCK; */    /*  11/1/00 */
+            //return VLC_NO_LAST_BIT;
+            i = VLC_NO_LAST_BIT;
+            last = 1;
+            sum = 1;    /* no of coefficients should not get reset   03/07/2002 */
+            break;
+        }
+
+        k = zigzag_inv[i];
+
+        if (run_level.sign == 1)
+        {
+            temp = (-(int32)(2 * run_level.level + 1) * qmat[k] * QP + 15) >> 4; /*  03/23/01 */
+            if (temp < -2048) temp = - 2048;
+        }
+        else
+        {
+            temp = ((int32)(2 * run_level.level + 1) * qmat[k] * QP) >> 4; /*  03/23/01 */
+            if (temp > 2047) temp = 2047;
+        }
+
+        datablock[k] = (int)temp;
+
+#ifdef FAST_IDCT
+        bitmapcol[k&0x7] |= mask[k>>3];
+#endif
+        sum ^= temp;
+
+        i++;
+    }
+    while (!last);
+
+    if ((sum & 1) == 0)
+    {
+        datablock[63] = datablock[63] ^ 0x1;
+#ifdef FAST_IDCT   /*  7/5/01, need to update bitmap */
+        if (datablock[63])
+            bitmapcol[7] |= 1;
+#endif
+        i = NCOEFF_BLOCK;
+    }
+
+
+#ifdef FAST_IDCT
+    if (i > 10)
+    {
+        for (k = 1; k < 4; k++)               /*  07/19/01 */
+        {
+            if (bitmapcol[k] != 0)
+            {
+                (*bitmaprow) |= mask[k];
+            }
+        }
+    }
+#endif
+
+    return i;
+}
+#endif
+/***********************************************************CommentBegin******
+*
+* -- VlcDequantIntraH263Block -- Decodes the DCT coefficients of one 8x8 block and perform
+            dequantization in H.263 mode for INTRA block.
+    Date:       08/08/2000
+    Modified:               3/21/01
+                clean up, added clipping, 16-bit int case, removed multiple zigzaging
+******************************************************************************/
+
+
+int VlcDequantH263IntraBlock(VideoDecData *video, int comp, int switched,
+                             uint8 *bitmapcol, uint8 *bitmaprow)
+{
+    BitstreamDecVideo *stream = video->bitstream;
+    int16 *datablock = video->mblock->block[comp]; /* 10/20/2000, assume it has been reset of all-zero !!!*/
+    int32 temp;
+    int mbnum = video->mbnum;
+    uint CBP = video->headerInfo.CBP[mbnum];
+    int QP = video->QPMB[mbnum];
+    typeDCStore *DC = video->predDC + mbnum;
+    int x_pos = video->mbnum_col;
+    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
+    typeDCACStore *DCAC_col = video->predDCAC_col;
+    uint ACpred_flag = (uint) video->acPredFlag[mbnum];
+
+    /*** VLC *****/
+    int i, j, k;
+    Tcoef run_level;
+    int last, return_status;
+    VlcDecFuncP vlcDecCoeff;
+    int direction;
+    const int *inv_zigzag;
+
+    /*** Quantizer ****/
+    int dc_scaler;
+    int sgn_coeff;
+
+
+
+    const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
+    const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
+
+    int16 *dcac_row, *dcac_col;
+
+    dcac_row = (*DCAC_row)[B_Xtab[comp]];
+    dcac_col = (*DCAC_col)[B_Ytab[comp]];
+
+#ifdef FAST_IDCT
+    *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+#endif
+    /* select which Huffman table to be used */
+    vlcDecCoeff = video->vlcDecCoeffIntra;
+
+    dc_scaler = (comp < 4) ? video->mblock->DCScalarLum : video->mblock->DCScalarChr;
+
+    /* perform only VLC decoding */
+    doDCACPrediction(video, comp, datablock, &direction);
+    if (!ACpred_flag) direction = 0;
+
+    inv_zigzag = zigzag_inv + (ACpred_flag << 6) + (direction << 6);  /*  04/17/01 */
+
+    i = 1;
+    if (CBP & (1 << (5 - comp)))
+    {
+        i = 1 - switched;
+        do
+        {
+            return_status = (*vlcDecCoeff)(stream, &run_level);
+            if (return_status != PV_SUCCESS)
+            {
+                last = 1;/* 11/1/2000 let it slips undetected, just like
+                         in original version */
+                i = VLC_ERROR;
+                ACpred_flag = 0;   /* no of coefficients should not get reset   03/07/2002 */
+                break;
+            }
+
+            i += run_level.run;
+            last = run_level.last;
+            if (i >= 64)
+            {
+                ACpred_flag = 0;    /* no of coefficients should not get reset   03/07/2002 */
+                i = VLC_NO_LAST_BIT;
+                last = 1;
+                break;
+            }
+
+            k = inv_zigzag[i];
+
+            if (run_level.sign == 1)
+            {
+                datablock[k] -= run_level.level;
+                sgn_coeff = -1;
+            }
+            else
+            {
+                datablock[k] += run_level.level;
+                sgn_coeff = 1;
+            }
+
+
+            if (AC_rowcol[k])   /*  10/25/2000 */
+            {
+                temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
+                if (temp > 2047) temp = 2047;            /*  03/14/01 */
+                else if (temp < -2048)  temp = -2048;
+                datablock[k] = (int16) temp;
+
+#ifdef FAST_IDCT
+                bitmapcol[k&0x7] |= mask[k>>3];
+#endif
+            }
+
+            i++;
+        }
+        while (!last);
+
+    }
+
+    ///// NEED TO DEQUANT THOSE PREDICTED AC COEFF
+    /* dequantize the rest of AC predicted coeff that haven't been dequant */
+    if (ACpred_flag)
+    {
+
+        i = NCOEFF_BLOCK; /* otherwise, FAST IDCT won't work correctly,  10/18/2000 */
+
+        if (!direction) /* check vertical */
+        {
+
+            dcac_row[0]  = datablock[1];
+            dcac_row[1]  = datablock[2];
+            dcac_row[2]  = datablock[3];
+            dcac_row[3]  = datablock[4];
+            dcac_row[4]  = datablock[5];
+            dcac_row[5]  = datablock[6];
+            dcac_row[6]  = datablock[7];
+
+            for (j = 0, k = 8; k < 64; k += 8, j++)
+            {
+                dcac_col[j] = datablock[k];
+                if (dcac_col[j])
+                {
+                    if (datablock[k] > 0)
+                    {
+                        if (datablock[k] > 2047) dcac_col[j] = 2047;
+                        sgn_coeff = 1;
+                    }
+                    else
+                    {
+                        if (datablock[k] < -2048) dcac_col[j] = -2048;
+                        sgn_coeff = -1;
+                    }
+                    temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
+                    if (temp > 2047) temp = 2047;            /*  03/14/01 */
+                    else if (temp < -2048)  temp = -2048;
+                    datablock[k] = (int16) temp;
+#ifdef FAST_IDCT
+                    bitmapcol[0] |= mask[k>>3];
+#endif
+
+                }
+            }
+
+            for (k = 1; k < 8; k++)
+            {
+                if (datablock[k])
+                {
+                    sgn_coeff = (datablock[k] > 0) ? 1 : -1;
+                    temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
+                    if (temp > 2047) temp = 2047;            /*  03/14/01 */
+                    else if (temp < -2048)  temp = -2048;
+                    datablock[k] = (int16) temp;
+#ifdef FAST_IDCT
+                    bitmapcol[k] |= 128;
+#endif
+
+                }
+            }
+        }
+        else
+        {
+
+            dcac_col[0]  = datablock[8];
+            dcac_col[1]  = datablock[16];
+            dcac_col[2]  = datablock[24];
+            dcac_col[3]  = datablock[32];
+            dcac_col[4]  = datablock[40];
+            dcac_col[5]  = datablock[48];
+            dcac_col[6]  = datablock[56];
+
+
+            for (j = 0, k = 1; k < 8; k++, j++)
+            {
+                dcac_row[j] = datablock[k];
+                if (dcac_row[j])
+                {
+                    if (datablock[k] > 0)
+                    {
+                        if (datablock[k] > 2047) dcac_row[j] = 2047;
+                        sgn_coeff = 1;
+                    }
+                    else
+                    {
+                        if (datablock[k] < -2048) dcac_row[j] = -2048;
+                        sgn_coeff = -1;
+                    }
+
+                    temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
+                    if (temp > 2047) temp = 2047;            /*  03/14/01 */
+                    else if (temp < -2048)  temp = -2048;
+                    datablock[k] = (int) temp;
+#ifdef FAST_IDCT
+                    bitmapcol[k] |= 128;
+#endif
+
+                }
+            }
+            for (k = 8; k < 64; k += 8)
+            {
+                if (datablock[k])
+                {
+                    sgn_coeff = (datablock[k] > 0) ? 1 : -1;
+                    temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
+                    if (temp > 2047) temp = 2047;            /*  03/14/01 */
+                    else if (temp < -2048)  temp = -2048;
+                    datablock[k] = (int16) temp;
+#ifdef FAST_IDCT
+                    bitmapcol[0] |= mask[k>>3];
+#endif
+                }
+            }
+
+        }
+    }
+    else
+    {
+        dcac_row[0]  = datablock[1];
+        dcac_row[1]  = datablock[2];
+        dcac_row[2]  = datablock[3];
+        dcac_row[3]  = datablock[4];
+        dcac_row[4]  = datablock[5];
+        dcac_row[5]  = datablock[6];
+        dcac_row[6]  = datablock[7];
+
+        dcac_col[0]  = datablock[8];
+        dcac_col[1]  = datablock[16];
+        dcac_col[2]  = datablock[24];
+        dcac_col[3]  = datablock[32];
+        dcac_col[4]  = datablock[40];
+        dcac_col[5]  = datablock[48];
+        dcac_col[6]  = datablock[56];
+
+        for (k = 1; k < 8; k++)
+        {
+            if (datablock[k])
+            {
+                sgn_coeff = (datablock[k] > 0) ? 1 : -1;
+                temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
+                if (temp > 2047) temp = 2047;            /*  03/14/01 */
+                else if (temp < -2048)  temp = -2048;
+                datablock[k] = (int16) temp;
+#ifdef FAST_IDCT
+                bitmapcol[k] |= 128;
+#endif
+            }
+        }
+        for (k = 8; k < 64; k += 8)
+        {
+            if (datablock[k])
+            {
+                sgn_coeff = (datablock[k] > 0) ? 1 : -1;
+                temp = (int32)QP * (2 * datablock[k] + sgn_coeff) - sgn_coeff + (QP & 1) * sgn_coeff;
+                if (temp > 2047) temp = 2047;            /*  03/14/01 */
+                else if (temp < -2048)  temp = -2048;
+                datablock[k] = (int16) temp;
+#ifdef FAST_IDCT
+                bitmapcol[0] |= mask[k>>3];
+#endif
+            }
+        }
+    }
+    if (datablock[0])
+    {
+#ifdef FAST_IDCT
+        bitmapcol[0] |= 128;
+#endif
+
+        temp = (int32)datablock[0] * dc_scaler;
+        if (temp > 2047) temp = 2047;            /*  03/14/01 */
+        else if (temp < -2048)  temp = -2048;
+        datablock[0] = (int16)temp;
+    }
+
+
+#ifdef FAST_IDCT
+    if (i > 10)
+    {
+        for (k = 1; k < 4; k++)  /* if i > 10 then k = 0 does not matter  */
+        {
+            if (bitmapcol[k] != 0)
+            {
+                (*bitmaprow) |= mask[k]; /* (1<<(7-i)); */
+            }
+        }
+    }
+#endif
+
+    /* Store the qcoeff-values needed later for prediction */
+    (*DC)[comp] = datablock[0];
+    return i;
+}
+
+int VlcDequantH263IntraBlock_SH(VideoDecData *video, int comp, uint8 *bitmapcol, uint8 *bitmaprow)
+{
+    BitstreamDecVideo *stream = video->bitstream;
+    int16 *datablock = video->mblock->block[comp]; /*, 10/20/2000, assume it has been reset of all-zero !!!*/
+    int32 temp;
+    int mbnum = video->mbnum;
+    uint CBP = video->headerInfo.CBP[mbnum];
+    int16 QP = video->QPMB[mbnum];
+    typeDCStore *DC = video->predDC + mbnum;
+    int x_pos = video->mbnum_col;
+    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
+    typeDCACStore *DCAC_col = video->predDCAC_col;
+    uint ACpred_flag = (uint) video->acPredFlag[mbnum];
+
+    /*** VLC *****/
+    int i, k;
+    Tcoef run_level;
+    int last, return_status;
+    VlcDecFuncP vlcDecCoeff;
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    int direction;
+    const int *inv_zigzag;
+#endif
+    /*** Quantizer ****/
+
+
+
+    const int B_Xtab[6] = {0, 1, 0, 1, 2, 3};
+    const int B_Ytab[6] = {0, 0, 1, 1, 2, 3};
+
+    int16 *dcac_row, *dcac_col;
+
+    dcac_row = (*DCAC_row)[B_Xtab[comp]];
+    dcac_col = (*DCAC_col)[B_Ytab[comp]];
+    i = 1;
+
+#ifdef FAST_IDCT
+    *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+#endif
+
+    /* select which Huffman table to be used */
+    vlcDecCoeff = video->vlcDecCoeffIntra;
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    if (comp > 3)        /* ANNEX_T */
+    {
+        QP = video->QP_CHR;
+    }
+    if (!video->advanced_INTRA)
+    {
+#endif
+
+        if ((CBP & (1 << (5 - comp))) == 0)
+        {
+#ifdef FAST_IDCT
+            bitmapcol[0] = 128;
+            bitmapcol[1] = bitmapcol[2] = bitmapcol[3] = bitmapcol[4] = bitmapcol[5] = bitmapcol[6] = bitmapcol[7] = 0;
+#endif
+            datablock[0] <<= 3;  /* no need to clip */
+            return 1;//ncoeffs;
+        }
+        else
+        {
+            /* enter the zero run decoding loop */
+            do
+            {
+                return_status = (*vlcDecCoeff)(stream, &run_level);
+                if (return_status != PV_SUCCESS)
+                {
+                    last = 1;/*  11/1/2000 let it slips undetected, just like
+                             in original version */
+                    i = VLC_ERROR;
+                    break;
+                }
+
+                i += run_level.run;
+                last = run_level.last;
+                if (i >= 64)
+                {
+                    /*  i = NCOEFF_BLOCK; */    /*  11/1/00 */
+                    i = VLC_NO_LAST_BIT;
+                    last = 1;
+                    break;
+                }
+                k = zigzag_inv[i];
+
+                if (run_level.sign == 0)
+                {
+                    temp = (int32)QP * (2 * run_level.level + 1) - 1 + (QP & 1);
+                    if (temp > 2047) temp = 2047;
+                }
+                else
+                {
+                    temp = -(int32)QP * (2 * run_level.level + 1) + 1 - (QP & 1);
+                    if (temp < -2048) temp = -2048;
+                }
+
+
+                datablock[k] = (int16) temp;
+
+#ifdef FAST_IDCT
+                bitmapcol[k&0x7] |= mask[k>>3];
+#endif
+                i++;
+            }
+            while (!last);
+
+        }
+        /* no ACDC prediction when ACDC disable  */
+        if (datablock[0])
+        {
+#ifdef FAST_IDCT
+            bitmapcol[0] |= 128;
+#endif
+            datablock[0] <<= 3;        /* no need to clip  09/18/2001 */
+        }
+#ifdef PV_ANNEX_IJKT_SUPPORT
+    }
+    else  /* advanced_INTRA mode */
+    {
+        i = 1;
+        doDCACPrediction_I(video, comp, datablock);
+        /* perform only VLC decoding */
+        if (!ACpred_flag)
+        {
+            direction = 0;
+        }
+        else
+        {
+            direction = video->mblock->direction;
+        }
+
+        inv_zigzag = zigzag_inv + (ACpred_flag << 6) + (direction << 6);  /*  04/17/01 */
+
+        if (CBP & (1 << (5 - comp)))
+        {
+            i = 0;
+            do
+            {
+                return_status = (*vlcDecCoeff)(stream, &run_level);
+                if (return_status != PV_SUCCESS)
+                {
+                    last = 1;/*  11/1/2000 let it slips undetected, just like
+                                 in original version */
+                    i = VLC_ERROR;
+                    ACpred_flag = 0;   /* no of coefficients should not get reset   03/07/2002 */
+                    break;
+                }
+
+                i += run_level.run;
+                last = run_level.last;
+                if (i >= 64)
+                {
+                    /*                  i = NCOEFF_BLOCK; */    /*  11/1/00 */
+                    ACpred_flag = 0;    /* no of coefficients should not get reset   03/07/2002 */
+                    i = VLC_NO_LAST_BIT;
+                    last = 1;
+                    break;
+                }
+
+                k = inv_zigzag[i];
+
+                if (run_level.sign == 0)
+                {
+                    datablock[k] += (int16)QP * 2 * run_level.level;
+                    if (datablock[k] > 2047) datablock[k] = 2047;
+                }
+                else
+                {
+                    datablock[k] -= (int16)QP * 2 * run_level.level;
+                    if (datablock[k] < -2048) datablock[k] = -2048;
+                }
+#ifdef FAST_IDCT
+                bitmapcol[k&0x7] |= mask[k>>3];
+#endif
+
+                i++;
+            }
+            while (!last);
+
+        }
+        ///// NEED TO DEQUANT THOSE PREDICTED AC COEFF
+        /* dequantize the rest of AC predicted coeff that haven't been dequant */
+
+        if (ACpred_flag)
+        {
+            i = NCOEFF_BLOCK;
+            for (k = 1; k < 8; k++)
+            {
+                if (datablock[k])
+                {
+                    bitmapcol[k] |= 128;
+                }
+
+                if (datablock[k<<3])
+                {
+                    bitmapcol[0] |= mask[k];
+                }
+            }
+        }
+
+        dcac_row[0]  = datablock[1];
+        dcac_row[1]  = datablock[2];
+        dcac_row[2]  = datablock[3];
+        dcac_row[3]  = datablock[4];
+        dcac_row[4]  = datablock[5];
+        dcac_row[5]  = datablock[6];
+        dcac_row[6]  = datablock[7];
+
+        dcac_col[0]  = datablock[8];
+        dcac_col[1]  = datablock[16];
+        dcac_col[2]  = datablock[24];
+        dcac_col[3]  = datablock[32];
+        dcac_col[4]  = datablock[40];
+        dcac_col[5]  = datablock[48];
+        dcac_col[6]  = datablock[56];
+
+        if (datablock[0])
+        {
+#ifdef FAST_IDCT
+            bitmapcol[0] |= 128;
+#endif
+
+            datablock[0] |= 1;
+            if (datablock[0] < 0)
+            {
+                datablock[0] = 0;
+            }
+        }
+    }
+#endif
+
+#ifdef FAST_IDCT
+    if (i > 10)
+    {
+        for (k = 1; k < 4; k++)  /* if i > 10 then k = 0 does not matter  */
+        {
+            if (bitmapcol[k] != 0)
+            {
+                (*bitmaprow) |= mask[k]; /* (1<<(7-i)); */
+            }
+        }
+    }
+#endif
+
+    /* Store the qcoeff-values needed later for prediction */
+    (*DC)[comp] = datablock[0];
+    return i;
+}
+
+/***********************************************************CommentBegin******
+*
+* -- VlcDequantInterH263Block -- Decodes the DCT coefficients of one 8x8 block and perform
+            dequantization in H.263 mode for INTER block.
+    Date:       08/08/2000
+    Modified:             3/21/01
+                clean up, added clipping, 16-bit int case
+******************************************************************************/
+
+
+int VlcDequantH263InterBlock(VideoDecData *video, int comp,
+                             uint8 *bitmapcol, uint8 *bitmaprow)
+{
+    BitstreamDecVideo *stream = video->bitstream;
+    int16 *datablock = video->mblock->block[comp]; /* 10/20/2000, assume it has been reset of all-zero !!!*/
+    int32 temp;
+    int mbnum = video->mbnum;
+    int QP = video->QPMB[mbnum];
+
+    /*** VLC *****/
+    int i, k;
+    Tcoef run_level;
+    int last, return_status;
+    VlcDecFuncP vlcDecCoeff;
+
+    /*** Quantizer ****/
+
+
+    i = 0;
+
+#ifdef FAST_IDCT
+    *((uint32*)bitmapcol) = *((uint32*)(bitmapcol + 4)) = 0;
+    *bitmaprow = 0;
+#endif
+
+    /* select which Huffman table to be used */
+    vlcDecCoeff = video->vlcDecCoeffInter;
+
+    /* enter the zero run decoding loop */
+    do
+    {
+        return_status = (*vlcDecCoeff)(stream, &run_level);
+        if (return_status != PV_SUCCESS)
+        {
+
+
+            last = 1;/*  11/1/2000 let it slips undetected, just like
+                     in original version */
+            i = -1;
+            break;
+        }
+
+        i += run_level.run;
+        last = run_level.last;
+        if (i >= 64)
+        {
+            i = -1;
+            last = 1;
+            break;
+        }
+
+        if (run_level.sign == 0)
+        {
+            temp = (int32)QP * (2 * run_level.level + 1) - 1 + (QP & 1);
+            if (temp > 2047) temp = 2047;
+
+        }
+        else
+        {
+            temp = -(int32)QP * (2 * run_level.level + 1) + 1 - (QP & 1);
+            if (temp < -2048) temp = -2048;
+        }
+
+        k = zigzag_inv[i];
+        datablock[k] = (int16)temp;
+#ifdef FAST_IDCT
+        bitmapcol[k&0x7] |= mask[k>>3];
+#endif
+        i++;
+    }
+    while (!last);
+
+#ifdef FAST_IDCT
+    if (i > 10)         /*  07/19/01 */
+    {
+        for (k = 1; k < 4; k++)       /*  if (i > 10 ) k = 0 does not matter */
+        {
+            if (bitmapcol[k] != 0)
+            {
+                (*bitmaprow) |= mask[k]; /* (1<<(7-i)); */
+            }
+        }
+    }
+#endif
+    return i;
+}
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/vlc_tab.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_tab.cpp
new file mode 100644
index 0000000..704992f
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/vlc_tab.cpp
@@ -0,0 +1,835 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include    "mp4dec_api.h"
+#include    "mp4def.h"
+#include    "mp4lib_int.h"
+#include    "vlc_dec_tab.h"
+#include    "max_level.h"
+
+
+const int intra_max_level[2][NCOEFF_BLOCK] =
+{
+    {27, 10,  5,  4,  3,  3,  3,  3,
+        2,  2,  1,  1,  1,  1,  1,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+    },
+
+    {8,  3,  2,  2,  2,  2,  2,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0
+    }
+};
+
+
+const int inter_max_level[2][NCOEFF_BLOCK] =
+{
+    {12,  6,  4,  3,  3,  3,  3,  2,
+        2,  2,  2,  1,  1,  1,  1,  1,
+        1,  1,  1,  1,  1,  1,  1,  1,
+        1,  1,  1,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0,
+        0,  0,  0,  0,  0,  0,  0,  0},
+
+    {3,  2,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0}
+};
+
+
+const int intra_max_run0[28] = { 999, 14,  9,  7,  3,  2,  1,
+                                 1,  1,  1,  1,  0,  0,  0,
+                                 0,  0,  0,  0,  0,  0,  0,
+                                 0,  0,  0,  0,  0,  0,  0
+                               };
+
+
+const int intra_max_run1[9] = { 999, 20,  6,
+                                1,  0,  0,
+                                0,  0,  0
+                              };
+
+const int inter_max_run0[13] = { 999,
+                                 26, 10,  6,  2,  1,  1,
+                                 0,  0,  0,  0,  0,  0
+                               };
+
+
+const int inter_max_run1[4] = { 999, 40,  1,  0 };
+
+const VLCshorttab PV_TMNMVtab0[] =
+{
+    {3, 4}, { -3, 4}, {2, 3}, {2, 3}, { -2, 3}, { -2, 3}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
+    { -1, 2}, { -1, 2}, { -1, 2}, { -1, 2}
+};
+
+const VLCshorttab PV_TMNMVtab1[] =
+{
+    {12, 10}, { -12, 10}, {11, 10}, { -11, 10}, {10, 9}, {10, 9}, { -10, 9}, { -10, 9},
+    {9, 9}, {9, 9}, { -9, 9}, { -9, 9}, {8, 9}, {8, 9}, { -8, 9}, { -8, 9}, {7, 7}, {7, 7},
+    {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, { -7, 7}, { -7, 7}, { -7, 7}, { -7, 7},
+    { -7, 7}, { -7, 7}, { -7, 7}, { -7, 7}, {6, 7}, {6, 7}, {6, 7}, {6, 7}, {6, 7}, {6, 7},
+    {6, 7}, {6, 7}, { -6, 7}, { -6, 7}, { -6, 7}, { -6, 7}, { -6, 7}, { -6, 7}, { -6, 7},
+    { -6, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7}, { -5, 7},
+    { -5, 7}, { -5, 7}, { -5, 7}, { -5, 7}, { -5, 7}, { -5, 7}, { -5, 7}, {4, 6}, {4, 6}, {4, 6},
+    {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
+    {4, 6}, {4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6},
+    { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}, { -4, 6}
+};
+
+const VLCshorttab PV_TMNMVtab2[] =
+{
+    {32, 12}, { -32, 12}, {31, 12}, { -31, 12}, {30, 11}, {30, 11}, { -30, 11}, { -30, 11},
+    {29, 11}, {29, 11}, { -29, 11}, { -29, 11}, {28, 11}, {28, 11}, { -28, 11}, { -28, 11},
+    {27, 11}, {27, 11}, { -27, 11}, { -27, 11}, {26, 11}, {26, 11}, { -26, 11}, { -26, 11},
+    {25, 11}, {25, 11}, { -25, 11}, { -25, 11}, {24, 10}, {24, 10}, {24, 10}, {24, 10},
+    { -24, 10}, { -24, 10}, { -24, 10}, { -24, 10}, {23, 10}, {23, 10}, {23, 10}, {23, 10},
+    { -23, 10}, { -23, 10}, { -23, 10}, { -23, 10}, {22, 10}, {22, 10}, {22, 10}, {22, 10},
+    { -22, 10}, { -22, 10}, { -22, 10}, { -22, 10}, {21, 10}, {21, 10}, {21, 10}, {21, 10},
+    { -21, 10}, { -21, 10}, { -21, 10}, { -21, 10}, {20, 10}, {20, 10}, {20, 10}, {20, 10},
+    { -20, 10}, { -20, 10}, { -20, 10}, { -20, 10}, {19, 10}, {19, 10}, {19, 10}, {19, 10},
+    { -19, 10}, { -19, 10}, { -19, 10}, { -19, 10}, {18, 10}, {18, 10}, {18, 10}, {18, 10},
+    { -18, 10}, { -18, 10}, { -18, 10}, { -18, 10}, {17, 10}, {17, 10}, {17, 10}, {17, 10},
+    { -17, 10}, { -17, 10}, { -17, 10}, { -17, 10}, {16, 10}, {16, 10}, {16, 10}, {16, 10},
+    { -16, 10}, { -16, 10}, { -16, 10}, { -16, 10}, {15, 10}, {15, 10}, {15, 10}, {15, 10},
+    { -15, 10}, { -15, 10}, { -15, 10}, { -15, 10}, {14, 10}, {14, 10}, {14, 10}, {14, 10},
+    { -14, 10}, { -14, 10}, { -14, 10}, { -14, 10}, {13, 10}, {13, 10}, {13, 10}, {13, 10},
+    { -13, 10}, { -13, 10}, { -13, 10}, { -13, 10}
+};
+
+const VLCshorttab PV_MCBPCtab[] =
+{
+    {VLC_ERROR, 0},
+    {255, 9}, {52, 9}, {36, 9}, {20, 9}, {49, 9}, {35, 8}, {35, 8}, {19, 8}, {19, 8},
+    {50, 8}, {50, 8}, {51, 7}, {51, 7}, {51, 7}, {51, 7}, {34, 7}, {34, 7}, {34, 7},
+    {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7}, {33, 7}, {33, 7}, {33, 7}, {33, 7},
+    {17, 7}, {17, 7}, {17, 7}, {17, 7}, {4, 6}, {4, 6}, {4, 6}, {4, 6}, {4, 6},
+    {4, 6}, {4, 6}, {4, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6}, {48, 6},
+    {48, 6}, {48, 6}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
+    {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5}, {3, 5},
+    {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
+    {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
+    {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
+    {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
+    {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
+    {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
+    {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
+    {16, 4}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
+    {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
+    {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
+    {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
+    {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
+    {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
+    {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3},
+    {2, 3}, {2, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
+    {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
+    {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
+    {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
+    {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
+    {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
+    {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
+    {1, 3}, {1, 3}, {1, 3}
+};
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+const VLCshorttab PV_MCBPCtab1[] =
+{
+    {5, 11}, {5, 11},  {5, 11}, {5, 11}, {21, 13}, {21, 13}, {37, 13}, {53, 13},
+};
+#endif
+const VLCshorttab PV_MCBPCtabintra[] =
+{
+    {VLC_ERROR, 0},
+    {20, 6}, {36, 6}, {52, 6}, {4, 4}, {4, 4}, {4, 4},
+    {4, 4}, {19, 3}, {19, 3}, {19, 3}, {19, 3}, {19, 3},
+    {19, 3}, {19, 3}, {19, 3}, {35, 3}, {35, 3}, {35, 3},
+    {35, 3}, {35, 3}, {35, 3}, {35, 3}, {35, 3}, {51, 3},
+    {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3}, {51, 3},
+    {51, 3}
+};
+
+
+
+const VLCshorttab PV_CBPYtab[48] =
+{
+    {VLC_ERROR, 0}, {VLC_ERROR, 0}, {6, 6}, {9, 6}, {8, 5}, {8, 5}, {4, 5}, {4, 5},
+    {2, 5}, {2, 5}, {1, 5}, {1, 5}, {0, 4}, {0, 4}, {0, 4}, {0, 4},
+    {12, 4}, {12, 4}, {12, 4}, {12, 4}, {10, 4}, {10, 4}, {10, 4}, {10, 4},
+    {14, 4}, {14, 4}, {14, 4}, {14, 4}, {5, 4}, {5, 4}, {5, 4}, {5, 4},
+    {13, 4}, {13, 4}, {13, 4}, {13, 4}, {3, 4}, {3, 4}, {3, 4}, {3, 4},
+    {11, 4}, {11, 4}, {11, 4}, {11, 4}, {7, 4}, {7, 4}, {7, 4}, {7, 4}
+};
+
+
+
+const VLCtab2 PV_DCT3Dtab0[] =
+{
+    {0x8, 1, 1, 7}, {0x7, 1, 1, 7}, {0x6, 1, 1, 7}, {0x5, 1, 1, 7}, {0xc, 1, 0, 7}, {0xb, 1, 0, 7},
+    {0xa, 1, 0, 7}, {0x0, 4, 0, 7}, {0x4, 1, 1, 6}, {0x4, 1, 1, 6}, {0x3, 1, 1, 6}, {0x3, 1, 1, 6},
+    {0x2, 1, 1, 6}, {0x2, 1, 1, 6}, {0x1, 1, 1, 6}, {0x1, 1, 1, 6}, {0x9, 1, 0, 6}, {0x9, 1, 0, 6},
+    {0x8, 1, 0, 6}, {0x8, 1, 0, 6}, {0x7, 1, 0, 6}, {0x7, 1, 0, 6}, {0x6, 1, 0, 6}, {0x6, 1, 0, 6},
+    {0x1, 2, 0, 6}, {0x1, 2, 0, 6}, {0x0, 3, 0, 6}, {0x0, 3, 0, 6}, {0x5, 1, 0, 5}, {0x5, 1, 0, 5},
+    {0x5, 1, 0, 5}, {0x5, 1, 0, 5}, {0x4, 1, 0, 5}, {0x4, 1, 0, 5}, {0x4, 1, 0, 5}, {0x4, 1, 0, 5},
+    {0x3, 1, 0, 5}, {0x3, 1, 0, 5}, {0x3, 1, 0, 5}, {0x3, 1, 0, 5}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4},
+    {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3},
+    {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3},
+    {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3}, {0x1, 1, 0, 3},
+    {0x2, 1, 0, 4}, {0x2, 1, 0, 4}, {0x2, 1, 0, 4}, {0x2, 1, 0, 4}, {0x2, 1, 0, 4}, {0x2, 1, 0, 4},
+    {0x2, 1, 0, 4}, {0x2, 1, 0, 4}, {0x0, 2, 0, 4}, {0x0, 2, 0, 4}, {0x0, 2, 0, 4}, {0x0, 2, 0, 4},
+    {0x0, 2, 0, 4}, {0x0, 2, 0, 4}, {0x0, 2, 0, 4}, {0x0, 2, 0, 4}
+};
+
+
+const VLCtab2 PV_DCT3Dtab1[] =
+{
+    {0x0, 9, 0, 10}, {0x0, 8, 0, 10}, {0x18, 1, 1, 9}, {0x18, 1, 1, 9}, {0x17, 1, 1, 9}, {0x17, 1, 1, 9},
+    {0x16, 1, 1, 9}, {0x16, 1, 1, 9}, {0x15, 1, 1, 9}, {0x15, 1, 1, 9}, {0x14, 1, 1, 9}, {0x14, 1, 1, 9},
+    {0x13, 1, 1, 9}, {0x13, 1, 1, 9}, {0x12, 1, 1, 9}, {0x12, 1, 1, 9}, {0x11, 1, 1, 9}, {0x11, 1, 1, 9},
+    {0x0, 2, 1, 9}, {0x0, 2, 1, 9}, {0x16, 1, 0, 9}, {0x16, 1, 0, 9}, {0x15, 1, 0, 9}, {0x15, 1, 0, 9},
+    {0x14, 1, 0, 9}, {0x14, 1, 0, 9}, {0x13, 1, 0, 9}, {0x13, 1, 0, 9}, {0x12, 1, 0, 9}, {0x12, 1, 0, 9},
+    {0x11, 1, 0, 9}, {0x11, 1, 0, 9}, {0x10, 1, 0, 9}, {0x10, 1, 0, 9}, {0xf, 1, 0, 9}, {0xf, 1, 0, 9},
+    {0x4, 2, 0, 9}, {0x4, 2, 0, 9}, {0x3, 2, 0, 9}, {0x3, 2, 0, 9}, {0x0, 7, 0, 9}, {0x0, 7, 0, 9},
+    {0x0, 6, 0, 9}, {0x0, 6, 0, 9}, {0x10, 1, 1, 8}, {0x10, 1, 1, 8}, {0x10, 1, 1, 8}, {0x10, 1, 1, 8},
+    {0xf, 1, 1, 8}, {0xf, 1, 1, 8}, {0xf, 1, 1, 8}, {0xf, 1, 1, 8}, {0xe, 1, 1, 8}, {0xe, 1, 1, 8},
+    {0xe, 1, 1, 8}, {0xe, 1, 1, 8}, {0xd, 1, 1, 8}, {0xd, 1, 1, 8}, {0xd, 1, 1, 8}, {0xd, 1, 1, 8},
+    {0xc, 1, 1, 8}, {0xc, 1, 1, 8}, {0xc, 1, 1, 8}, {0xc, 1, 1, 8}, {0xb, 1, 1, 8}, {0xb, 1, 1, 8},
+    {0xb, 1, 1, 8}, {0xb, 1, 1, 8}, {0xa, 1, 1, 8}, {0xa, 1, 1, 8}, {0xa, 1, 1, 8}, {0xa, 1, 1, 8},
+    {0x9, 1, 1, 8}, {0x9, 1, 1, 8}, {0x9, 1, 1, 8}, {0x9, 1, 1, 8}, {0xe, 1, 0, 8}, {0xe, 1, 0, 8},
+    {0xe, 1, 0, 8}, {0xe, 1, 0, 8}, {0xd, 1, 0, 8}, {0xd, 1, 0, 8}, {0xd, 1, 0, 8}, {0xd, 1, 0, 8},
+    {0x2, 2, 0, 8}, {0x2, 2, 0, 8}, {0x2, 2, 0, 8}, {0x2, 2, 0, 8}, {0x1, 3, 0, 8}, {0x1, 3, 0, 8},
+    {0x1, 3, 0, 8}, {0x1, 3, 0, 8}, {0x0, 5, 0, 8}, {0x0, 5, 0, 8}, {0x0, 5, 0, 8}, {0x0, 5, 0, 8}
+};
+
+
+const VLCtab2 PV_DCT3Dtab2[] =
+{
+    {0x1, 2, 1, 11}, {0x1, 2, 1, 11}, {0x0, 3, 1, 11}, {0x0, 3, 1, 11}, {0x0, 0xb, 0, 11}, {0x0, 0xb, 0, 11},
+    {0x0, 0xa, 0, 11}, {0x0, 0xa, 0, 11}, {0x1c, 1, 1, 10}, {0x1c, 1, 1, 10}, {0x1c, 1, 1, 10}, {0x1c, 1, 1, 10},
+    {0x1b, 1, 1, 10}, {0x1b, 1, 1, 10}, {0x1b, 1, 1, 10}, {0x1b, 1, 1, 10}, {0x1a, 1, 1, 10}, {0x1a, 1, 1, 10},
+    {0x1a, 1, 1, 10}, {0x1a, 1, 1, 10}, {0x19, 1, 1, 10}, {0x19, 1, 1, 10}, {0x19, 1, 1, 10}, {0x19, 1, 1, 10},
+    {0x9, 2, 0, 10}, {0x9, 2, 0, 10}, {0x9, 2, 0, 10}, {0x9, 2, 0, 10}, {0x8, 2, 0, 10}, {0x8, 2, 0, 10},
+    {0x8, 2, 0, 10}, {0x8, 2, 0, 10}, {0x7, 2, 0, 10}, {0x7, 2, 0, 10}, {0x7, 2, 0, 10}, {0x7, 2, 0, 10},
+    {0x6, 2, 0, 10}, {0x6, 2, 0, 10}, {0x6, 2, 0, 10}, {0x6, 2, 0, 10}, {0x5, 2, 0, 10}, {0x5, 2, 0, 10},
+    {0x5, 2, 0, 10}, {0x5, 2, 0, 10}, {0x3, 3, 0, 10}, {0x3, 3, 0, 10}, {0x3, 3, 0, 10}, {0x3, 3, 0, 10},
+    {0x2, 3, 0, 10}, {0x2, 3, 0, 10}, {0x2, 3, 0, 10}, {0x2, 3, 0, 10}, {0x1, 4, 0, 10}, {0x1, 4, 0, 10},
+    {0x1, 4, 0, 10}, {0x1, 4, 0, 10}, {0x0, 0xc, 0, 11}, {0x0, 0xc, 0, 11}, {0x1, 5, 0, 11}, {0x1, 5, 0, 11},
+    {0x17, 1, 0, 11}, {0x17, 1, 0, 11}, {0x18, 1, 0, 11}, {0x18, 1, 0, 11}, {0x1d, 1, 1, 11}, {0x1d, 1, 1, 11},
+    {0x1e, 1, 1, 11}, {0x1e, 1, 1, 11}, {0x1f, 1, 1, 11}, {0x1f, 1, 1, 11}, {0x20, 1, 1, 11}, {0x20, 1, 1, 11},
+    {0x1, 6, 0, 12}, {0x2, 4, 0, 12}, {0x4, 3, 0, 12}, {0x5, 3, 0, 12}, {0x6, 3, 0, 12}, {0xa, 2, 0, 12},
+    {0x19, 1, 0, 12}, {0x1a, 1, 0, 12}, {0x21, 1, 1, 12}, {0x22, 1, 1, 12}, {0x23, 1, 1, 12}, {0x24, 1, 1, 12},
+    {0x25, 1, 1, 12}, {0x26, 1, 1, 12}, {0x27, 1, 1, 12}, {0x28, 1, 1, 12}, {0xbf, 0xf, 1, 7},
+    {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7},
+    {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7},
+    {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7},
+    {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7},
+    {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7}, {0xbf, 0xf, 1, 7},
+    {0xbf, 0xf, 1, 7}
+};
+
+/* New tables for Intra luminance blocks */
+
+const VLCtab2 PV_DCT3Dtab3[] =
+{
+    {0x4, 1, 1, 7}, {0x3, 1, 1, 7}, {0x6, 1, 0, 7}, {0x5, 1, 1, 7},
+    {0x7, 1, 0, 7}, {0x2, 2, 0, 7}, {0x1, 3, 0, 7}, {0x0, 9, 0, 7},
+    {0x0, 2, 1, 6}, {0x0, 2, 1, 6}, {0x5, 1, 0, 6}, {0x5, 1, 0, 6},
+    {0x2, 1, 1, 6}, {0x2, 1, 1, 6}, {0x1, 1, 1, 6}, {0x1, 1, 1, 6},
+    {0x4, 1, 0, 6}, {0x4, 1, 0, 6}, {0x3, 1, 0, 6}, {0x3, 1, 0, 6},
+    {0x0, 8, 0, 6}, {0x0, 8, 0, 6}, {0x0, 7, 0, 6}, {0x0, 7, 0, 6},
+    {0x1, 2, 0, 6}, {0x1, 2, 0, 6}, {0x0, 6, 0, 6}, {0x0, 6, 0, 6},
+    {0x2, 1, 0, 5}, {0x2, 1, 0, 5}, {0x2, 1, 0, 5}, {0x2, 1, 0, 5},
+    {0x0, 5, 0, 5}, {0x0, 5, 0, 5}, {0x0, 5, 0, 5}, {0x0, 5, 0, 5},
+    {0x0, 4, 0, 5}, {0x0, 4, 0, 5}, {0x0, 4, 0, 5}, {0x0, 4, 0, 5},
+    {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4},
+    {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3},
+    {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3},
+    {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3},
+    {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3},
+    {0x1, 1, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4},
+    {0x1, 1, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4},
+    {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x0, 3, 0, 4},
+    {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x0, 3, 0, 4}
+};
+
+const VLCtab2 PV_DCT3Dtab4[] =
+{
+    {0x0, 0x12, 0, 10}, {0x0, 0x11, 0, 10}, {0xe, 1, 1, 9}, {0xe, 1, 1, 9},
+    {0xd, 1, 1, 9}, {0xd, 1, 1, 9}, {0xc, 1, 1, 9}, {0xc, 1, 1, 9},
+    {0xb, 1, 1, 9}, {0xb, 1, 1, 9}, {0xa, 1, 1, 9}, {0xa, 1, 1, 9},
+    {0x1, 2, 1, 9}, {0x1, 2, 1, 9}, {0x0, 4, 1, 9}, {0x0, 4, 1, 9},
+    {0xc, 1, 0, 9}, {0xc, 1, 0, 9}, {0xb, 1, 0, 9}, {0xb, 1, 0, 9},
+    {0x7, 2, 0, 9}, {0x7, 2, 0, 9}, {0x6, 2, 0, 9}, {0x6, 2, 0, 9},
+    {0x5, 2, 0, 9}, {0x5, 2, 0, 9}, {0x3, 3, 0, 9}, {0x3, 3, 0, 9},
+    {0x2, 3, 0, 9}, {0x2, 3, 0, 9}, {0x1, 6, 0, 9}, {0x1, 6, 0, 9},
+    {0x1, 5, 0, 9}, {0x1, 5, 0, 9}, {0x0, 0x10, 0, 9}, {0x0, 0x10, 0, 9},
+    {0x4, 2, 0, 9}, {0x4, 2, 0, 9}, {0x0, 0xf, 0, 9}, {0x0, 0xf, 0, 9},
+    {0x0, 0xe, 0, 9}, {0x0, 0xe, 0, 9}, {0x0, 0xd, 0, 9}, {0x0, 0xd, 0, 9},
+    {0x8, 1, 1, 8}, {0x8, 1, 1, 8}, {0x8, 1, 1, 8}, {0x8, 1, 1, 8},
+    {0x7, 1, 1, 8}, {0x7, 1, 1, 8}, {0x7, 1, 1, 8}, {0x7, 1, 1, 8},
+    {0x6, 1, 1, 8}, {0x6, 1, 1, 8}, {0x6, 1, 1, 8}, {0x6, 1, 1, 8},
+    {0x0, 3, 1, 8}, {0x0, 3, 1, 8}, {0x0, 3, 1, 8}, {0x0, 3, 1, 8},
+    {0xa, 1, 0, 8}, {0xa, 1, 0, 8}, {0xa, 1, 0, 8}, {0xa, 1, 0, 8},
+    {0x9, 1, 0, 8}, {0x9, 1, 0, 8}, {0x9, 1, 0, 8}, {0x9, 1, 0, 8},
+    {0x8, 1, 0, 8}, {0x8, 1, 0, 8}, {0x8, 1, 0, 8}, {0x8, 1, 0, 8},
+    {0x9, 1, 1, 8}, {0x9, 1, 1, 8}, {0x9, 1, 1, 8}, {0x9, 1, 1, 8},
+    {0x3, 2, 0, 8}, {0x3, 2, 0, 8}, {0x3, 2, 0, 8}, {0x3, 2, 0, 8},
+    {0x1, 4, 0, 8}, {0x1, 4, 0, 8}, {0x1, 4, 0, 8}, {0x1, 4, 0, 8},
+    {0x0, 0xc, 0, 8}, {0x0, 0xc, 0, 8}, {0x0, 0xc, 0, 8}, {0x0, 0xc, 0, 8},
+    {0x0, 0xb, 0, 8}, {0x0, 0xb, 0, 8}, {0x0, 0xb, 0, 8}, {0x0, 0xb, 0, 8},
+    {0x0, 0xa, 0, 8}, {0x0, 0xa, 0, 8}, {0x0, 0xa, 0, 8}, {0x0, 0xa, 0, 8}
+};
+
+const VLCtab2 PV_DCT3Dtab5[] =
+{
+    {0x0, 7, 1, 11}, {0x0, 7, 1, 11}, {0x0, 6, 1, 11}, {0x0, 6, 1, 11},
+    {0x0, 0x16, 0, 11}, {0x0, 0x16, 0, 11}, {0x0, 0x15, 0, 11}, {0x0, 0x15, 0, 11},
+    {0x2, 2, 1, 10}, {0x2, 2, 1, 10}, {0x2, 2, 1, 10}, {0x2, 2, 1, 10},
+    {0x1, 3, 1, 10}, {0x1, 3, 1, 10}, {0x1, 3, 1, 10}, {0x1, 3, 1, 10},
+    {0x0, 5, 1, 10}, {0x0, 5, 1, 10}, {0x0, 5, 1, 10}, {0x0, 5, 1, 10},
+    {0xd, 1, 0, 10}, {0xd, 1, 0, 10}, {0xd, 1, 0, 10}, {0xd, 1, 0, 10},
+    {0x5, 3, 0, 10}, {0x5, 3, 0, 10}, {0x5, 3, 0, 10}, {0x5, 3, 0, 10},
+    {0x8, 2, 0, 10}, {0x8, 2, 0, 10}, {0x8, 2, 0, 10}, {0x8, 2, 0, 10},
+    {0x4, 3, 0, 10}, {0x4, 3, 0, 10}, {0x4, 3, 0, 10}, {0x4, 3, 0, 10},
+    {0x3, 4, 0, 10}, {0x3, 4, 0, 10}, {0x3, 4, 0, 10}, {0x3, 4, 0, 10},
+    {0x2, 4, 0, 10}, {0x2, 4, 0, 10}, {0x2, 4, 0, 10}, {0x2, 4, 0, 10},
+    {0x1, 7, 0, 10}, {0x1, 7, 0, 10}, {0x1, 7, 0, 10}, {0x1, 7, 0, 10},
+    {0x0, 0x14, 0, 10}, {0x0, 0x14, 0, 10}, {0x0, 0x14, 0, 10}, {0x0, 0x14, 0, 10},
+    {0x0, 0x13, 0, 10}, {0x0, 0x13, 0, 10}, {0x0, 0x13, 0, 10}, {0x0, 0x13, 0, 10},
+    {0x0, 0x17, 0, 11}, {0x0, 0x17, 0, 11}, {0x0, 0x18, 0, 11}, {0x0, 0x18, 0, 11},
+    {0x1, 8, 0, 11}, {0x1, 8, 0, 11}, {0x9, 2, 0, 11}, {0x9, 2, 0, 11},
+    {0x3, 2, 1, 11}, {0x3, 2, 1, 11}, {0x4, 2, 1, 11}, {0x4, 2, 1, 11},
+    {0xf, 1, 1, 11}, {0xf, 1, 1, 11}, {0x10, 1, 1, 11}, {0x10, 1, 1, 11},
+    {0, 0x19, 0, 12}, {0, 0x1a, 0, 12}, {0, 0x1b, 0, 12}, {1, 9, 0, 12},
+    {0x6, 3, 0, 12}, {0x1, 0xa, 0, 12}, {0x2, 5, 0, 12}, {0x7, 3, 0, 12},
+    {0xe, 1, 0, 12}, {0x0, 8, 1, 12}, {0x5, 2, 1, 12}, {0x6, 2, 1, 12},
+    {0x11, 1, 1, 12}, {0x12, 1, 1, 12}, {0x13, 1, 1, 12}, {0x14, 1, 1, 12},
+    {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7},
+    {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7},
+    {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7},
+    {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7},
+    {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7},
+    {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7},
+    {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7},
+    {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}, {0x1b, 0xff, 0, 7}
+};
+
+#ifdef PV_ANNEX_IJKT_SUPPORT
+const VLCtab2 PV_DCT3Dtab6[] =
+{
+    {0x0, 3, 1, 7}, {0x4, 1, 1, 7}, {0x6, 1, 1, 7}, {0x5, 1, 1, 7}, {0x1, 3, 0, 7}, {0x2, 2, 0, 7},
+    {0x0, 9, 0, 7}, {0x5, 1, 0, 7}, {0x0, 2, 1, 6}, {0x0, 2, 1, 6}, {0x3, 1, 1, 6}, {0x3, 1, 1, 6},
+    {0x2, 1, 1, 6}, {0x2, 1, 1, 6}, {0x1, 1, 1, 6}, {0x1, 1, 1, 6}, {0x0, 6, 0, 6}, {0x0, 6, 0, 6},
+    {0x0, 7, 0, 6}, {0x0, 7, 0, 6}, {0x0, 8, 0, 6}, {0x0, 8, 0, 6}, {0x4, 1, 0, 6}, {0x4, 1, 0, 6},
+    {0x1, 2, 0, 6}, {0x1, 2, 0, 6}, {0x3, 1, 0, 6}, {0x3, 1, 0, 6}, {0x2, 1, 0, 5}, {0x2, 1, 0, 5},
+    {0x2, 1, 0, 5}, {0x2, 1, 0, 5}, {0x0, 4, 0, 5}, {0x0, 4, 0, 5}, {0x0, 4, 0, 5}, {0x0, 4, 0, 5},
+    {0x0, 5, 0, 5}, {0x0, 5, 0, 5}, {0x0, 5, 0, 5}, {0x0, 5, 0, 5}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4},
+    {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4}, {0x0, 1, 1, 4},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 1, 0, 2},
+    {0x0, 1, 0, 2}, {0x0, 1, 0, 2}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3},
+    {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3},
+    {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3}, {0x0, 2, 0, 3},
+    {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x0, 3, 0, 4},
+    {0x0, 3, 0, 4}, {0x0, 3, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4},
+    {0x1, 1, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4}, {0x1, 1, 0, 4}
+};
+
+const VLCtab2 PV_DCT3Dtab7[] =
+{
+    {0xb, 1, 0, 10}, {0xa, 1, 0, 10}, {0x0, 5, 1, 9}, {0x0, 5, 1, 9}, {0x0, 6, 1, 9}, {0x0, 6, 1, 9},
+    {0x1, 2, 1, 9}, {0x1, 2, 1, 9}, {0x2, 2, 1, 9}, {0x2, 2, 1, 9}, {0xf, 1, 1, 9}, {0xf, 1, 1, 9},
+    {0x10, 1, 1, 9}, {0x10, 1, 1, 9}, {0x12, 1, 1, 9}, {0x12, 1, 1, 9}, {0x11, 1, 1, 9}, {0x11, 1, 1, 9},
+    {0xe, 1, 1, 9}, {0xe, 1, 1, 9}, {0x0, 13, 0, 9}, {0x0, 13, 0, 9}, {0x0, 14, 0, 9}, {0x0, 14, 0, 9},
+    {0x0, 15, 0, 9}, {0x0, 15, 0, 9}, {0x0, 16, 0, 9}, {0x0, 16, 0, 9}, {0x0, 17, 0, 9}, {0x0, 17, 0, 9},
+    {0x0, 18, 0, 9}, {0x0, 18, 0, 9}, {0x0, 11, 0, 9}, {0x0, 11, 0, 9}, {0x0, 12, 0, 9}, {0x0, 12, 0, 9},
+    {0x5, 2, 0, 9}, {0x5, 2, 0, 9}, {0x4, 2, 0, 9}, {0x4, 2, 0, 9}, {0x9, 1, 0, 9}, {0x9, 1, 0, 9},
+    {0x8, 1, 0, 9}, {0x8, 1, 0, 9}, {0x0, 4, 1, 8}, {0x0, 4, 1, 8}, {0x0, 4, 1, 8}, {0x0, 4, 1, 8},
+    {0x7, 1, 1, 8}, {0x7, 1, 1, 8}, {0x7, 1, 1, 8}, {0x7, 1, 1, 8}, {0x8, 1, 1, 8}, {0x8, 1, 1, 8},
+    {0x8, 1, 1, 8}, {0x8, 1, 1, 8}, {0xd, 1, 1, 8}, {0xd, 1, 1, 8}, {0xd, 1, 1, 8}, {0xd, 1, 1, 8},
+    {0xc, 1, 1, 8}, {0xc, 1, 1, 8}, {0xc, 1, 1, 8}, {0xc, 1, 1, 8}, {0xb, 1, 1, 8}, {0xb, 1, 1, 8},
+    {0xb, 1, 1, 8}, {0xb, 1, 1, 8}, {0xa, 1, 1, 8}, {0xa, 1, 1, 8}, {0xa, 1, 1, 8}, {0xa, 1, 1, 8},
+    {0x9, 1, 1, 8}, {0x9, 1, 1, 8}, {0x9, 1, 1, 8}, {0x9, 1, 1, 8}, {0x0, 10, 0, 8}, {0x0, 10, 0, 8},
+    {0x0, 10, 0, 8}, {0x0, 10, 0, 8}, {0x6, 1, 0, 8}, {0x6, 1, 0, 8}, {0x6, 1, 0, 8}, {0x6, 1, 0, 8},
+    {0x3, 2, 0, 8}, {0x3, 2, 0, 8}, {0x3, 2, 0, 8}, {0x3, 2, 0, 8}, {0x1, 4, 0, 8}, {0x1, 4, 0, 8},
+    {0x1, 4, 0, 8}, {0x1, 4, 0, 8}, {0x7, 1, 0, 8}, {0x7, 1, 0, 8}, {0x7, 1, 0, 8}, {0x7, 1, 0, 8}
+};
+
+
+const VLCtab2 PV_DCT3Dtab8[] =
+{
+    {0x13, 0x1, 1, 11}, {0x13, 0x1, 1, 11}, {0x14, 0x1, 1, 11}, {0x14, 0x1, 1, 11}, {0x9, 0x2, 0, 11}, {0x9, 0x2, 0, 11},
+    {0x4, 0x3, 0, 11}, {0x4, 0x3, 0, 11}, {0x0, 0x7, 1, 10}, {0x0, 0x7, 1, 10}, {0x0, 0x7, 1, 10}, {0x0, 0x7, 1, 10},
+    {0x1, 0x3, 1, 10}, {0x1, 0x3, 1, 10}, {0x1, 0x3, 1, 10}, {0x1, 0x3, 1, 10}, {0x3, 0x2, 1, 10}, {0x3, 0x2, 1, 10},
+    {0x3, 0x2, 1, 10}, {0x3, 0x2, 1, 10}, {0x4, 0x2, 1, 10}, {0x4, 0x2, 1, 10}, {0x4, 0x2, 1, 10}, {0x4, 0x2, 1, 10},
+    {0xc, 0x1, 0, 10}, {0xc, 0x1, 0, 10}, {0xc, 0x1, 0, 10}, {0xc, 0x1, 0, 10}, {0x2, 0x4, 0, 10}, {0x2, 0x4, 0, 10},
+    {0x2, 0x4, 0, 10}, {0x2, 0x4, 0, 10}, {0x8, 0x2, 0, 10}, {0x8, 0x2, 0, 10}, {0x8, 0x2, 0, 10}, {0x8, 0x2, 0, 10},
+    {0x7, 0x2, 0, 10}, {0x7, 0x2, 0, 10}, {0x7, 0x2, 0, 10}, {0x7, 0x2, 0, 10}, {0x6, 0x2, 0, 10}, {0x6, 0x2, 0, 10},
+    {0x6, 0x2, 0, 10}, {0x6, 0x2, 0, 10}, {0x3, 0x3, 0, 10}, {0x3, 0x3, 0, 10}, {0x3, 0x3, 0, 10}, {0x3, 0x3, 0, 10},
+    {0x2, 0x3, 0, 10}, {0x2, 0x3, 0, 10}, {0x2, 0x3, 0, 10}, {0x2, 0x3, 0, 10}, {0x1, 0x5, 0, 10}, {0x1, 0x5, 0, 10},
+    {0x1, 0x5, 0, 10}, {0x1, 0x5, 0, 10}, {0xd, 0x1, 0, 11}, {0xd, 0x1, 0, 11}, {0x1, 0x6, 0, 11}, {0x1, 0x6, 0, 11},
+    {0x0, 0x14, 0, 11}, {0x0, 0x14, 0, 11}, {0x0, 0x13, 0, 11}, {0x0, 0x13, 0, 11}, {0x2, 0x3, 1, 11}, {0x2, 0x3, 1, 11},
+    {0x1, 0x4, 1, 11}, {0x1, 0x4, 1, 11}, {0x0, 0x9, 1, 11}, {0x0, 0x9, 1, 11}, {0x0, 0x8, 1, 11}, {0x0, 0x8, 1, 11},
+    {0x1, 0x7, 0, 12}, {0x3, 0x4, 0, 12}, {0x5, 0x3, 0, 12}, {0x0, 0x19, 0, 12}, {0x0, 0x18, 0, 12}, {0x0, 0x17, 0, 12},
+    {0x0, 0x16, 0, 12}, {0x0, 0x15, 0, 12}, {0x15, 0x1, 1, 12}, {0x16, 0x1, 1, 12}, {0x17, 0x1, 1, 12}, {0x7, 0x2, 1, 12},
+    {0x6, 0x2, 1, 12}, {0x5, 0x2, 1, 12}, {0x3, 0x3, 1, 12}, {0x0, 0xa, 1, 12}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7},
+    {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7},
+    {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7},
+    {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7},
+    {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7},
+    {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}, {0x2f, 0x3f, 1, 7}
+};
+#endif
+/* RVLC tables */
+const int ptrRvlcTab[11] = {0, 24, 46, 66, 84, 100, 114, 126, 134, 140, 144};
+
+const VLCtab2 RvlcDCTtabIntra[170] = /* 00xxxx00 or 00xxxx01 */
+{
+    {27, 255, 0, 5},    /* 0000 is escape code */
+    {1, 1, 0, 4},
+    {2, 1, 0, 5},
+    {3, 1, 0, 5},
+    {4, 1, 0, 6},
+    {5, 1, 0, 6},
+    {6, 1, 0, 7},
+    {7, 1, 0, 7},
+    {8, 1, 0, 8},
+    {9, 1, 0, 8},
+    {10, 1, 0, 9},
+    {5, 2, 0, 9},
+    {11, 1, 0, 10},
+    {12, 1, 0, 10},
+    {13, 1, 0, 11},
+    {9, 2, 0, 11},
+    {10, 2, 0, 12},
+    {4, 4, 0, 12},
+    {14, 1, 0, 13},
+    {15, 1, 0, 13},
+    {16, 1, 0, 14},
+    {17, 1, 0, 14},
+    {0, 27, 0, 15},
+    {3, 9, 0, 15},
+    /* 010xxxx00 or 010xxxx01 */
+    {1, 2, 0, 5},
+    {0, 4, 0, 5},
+    {0, 5, 0, 6},
+    {0, 6, 0, 6},
+    {2, 2, 0, 7},
+    {1, 3, 0, 7},
+    {3, 2, 0, 8},
+    {4, 2, 0, 8},
+    {2, 3, 0, 9},
+    {3, 3, 0, 9},
+    {6, 2, 0, 10},
+    {7, 2, 0, 10},
+    {5, 3, 0, 11},
+    {6, 3, 0, 11},
+    {5, 4, 0, 12},
+    {6, 4, 0, 12},
+    {11, 2, 0, 13},
+    {8, 3, 0, 13},
+    {18, 1, 0, 14},
+    {8, 4, 0, 14},
+    {6, 5, 0, 15},
+    {7, 5, 0, 15},
+    /* 0110xxxx00 or 0110xxxx01 */
+    {3, 1, 1, 6},
+    {4, 1, 1, 6},
+    {0, 7, 0, 7},
+    {7, 1, 1, 7},
+    {1, 4, 0, 8},
+    {1, 5, 0, 8},
+    {1, 6, 0, 9},
+    {0, 10, 0, 9},
+    {8, 2, 0, 10},
+    {4, 3, 0, 10},
+    {7, 3, 0, 11},
+    {3, 4, 0, 11},
+    {3, 5, 0, 12},
+    {4, 5, 0, 12},
+    {9, 3, 0, 13},
+    {7, 4, 0, 13},
+    {5, 5, 0, 14},
+    {4, 6, 0, 14},
+    {9, 4, 0, 15},
+    {12, 2, 0, 15},
+    /* 01110xxxx00 or 01110xxxx01 */
+    {8, 1, 1, 7},
+    {9, 1, 1, 7},
+    {0, 8, 0, 8},
+    {0, 9, 0, 8},
+    {0, 11, 0, 9},
+    {1, 2, 1, 9},
+    {2, 4, 0, 10},
+    {1, 7, 0, 10},
+    {2, 5, 0, 11},
+    {2, 6, 0, 11},
+    {1, 10, 0, 12},
+    {0, 18, 0, 12},
+    {3, 6, 0, 13},
+    {2, 7, 0, 13},
+    {5, 6, 0, 14},
+    {3, 7, 0, 14},
+    {19, 1, 0, 15},
+    {1, 5, 1, 15},
+    /* 011110xxxx00 or 011110xxxx01 */
+    {0, 2, 1, 8},
+    {12, 1, 1, 8},
+    {15, 1, 1, 9},
+    {16, 1, 1, 9},
+    {0, 12, 0, 10},
+    {0, 13, 0, 10},
+    {1, 8, 0, 11},
+    {1, 9, 0, 11},
+    {0, 19, 0, 12},
+    {0, 22, 0, 12},
+    {2, 8, 0, 13},
+    {2, 9, 0, 13},
+    {3, 8, 0, 14},
+    {2, 10, 0, 14},
+    {2, 3, 1, 15},
+    {13, 2, 1, 15},
+    /* 0111110xxxx00 or 0111110xxxx01 */
+    {17, 1, 1, 9},
+    {18, 1, 1, 9},
+    {0, 14, 0, 10},
+    {21, 1, 1, 10},
+    {0, 15, 0, 11},
+    {0, 16, 0, 11},
+    {1, 3, 1, 12},
+    {3, 2, 1, 12},
+    {1, 11, 0, 13},
+    {0, 20, 0, 13},
+    {2, 11, 0, 14},
+    {1, 12, 0, 14},
+    {41, 1, 1, 15},
+    {42, 1, 1, 15},
+    /* 01111110xxxx00 or 01111110xxxx01 */
+    {22, 1, 1, 10},
+    {23, 1, 1, 10},
+    {0, 17, 0, 11},
+    {0, 3, 1, 11},
+    {4, 2, 1, 12},
+    {29, 1, 1, 12},
+    {0, 21, 0, 13},
+    {0, 23, 0, 13},
+    {1, 13, 0, 14},
+    {0, 24, 0, 14},
+    {43, 1, 1, 15},
+    {44, 1, 1, 15},
+    /* 011111110xxxx00 or 011111110xxxx01 */
+    {2, 2, 1, 11},
+    {26, 1, 1, 11},
+    {30, 1, 1, 12},
+    {31, 1, 1, 12},
+    {0, 4, 1, 13},
+    {5, 2, 1, 13},
+    {0, 25, 0, 14},
+    {0, 26, 0, 14},
+    /* 0111111110xxxx00 or 0111111110xxxx01 */
+    {32, 1, 1, 12},
+    {33, 1, 1, 12},
+    {6, 2, 1, 13},
+    {7, 2, 1, 13},
+    {0, 5, 1, 14},
+    {1, 4, 1, 14},
+    /* 01111111110xxxx00 or 01111111110xxxx01 */
+    {8, 2, 1, 13},
+    {9, 2, 1, 13},
+    {10, 2, 1, 14},
+    {11, 2, 1, 14},
+    /* 011111111110xxxx00 or 011111111110xxxx01 */
+    {12, 2, 1, 14},
+    {38, 1, 1, 14},
+    /* 1xxxx10 or 1xxxx11 from 11 zeros to 0 zeros*/
+    {0, 1, 0, 3},
+    {0, 2, 0, 3},
+    {0, 3, 0, 4},
+    {0, 1, 1, 4},
+    {1, 1, 1, 5},
+    {2, 1, 1, 5},
+    {5, 1, 1, 6},
+    {6, 1, 1, 6},
+    {10, 1, 1, 7},
+    {11, 1, 1, 7},
+    {13, 1, 1, 8},
+    {14, 1, 1, 8},
+    {19, 1, 1, 9},
+    {20, 1, 1, 9},
+    {24, 1, 1, 10},
+    {25, 1, 1, 10},
+    {27, 1, 1, 11},
+    {28, 1, 1, 11},
+    {34, 1, 1, 12},
+    {35, 1, 1, 12},
+    {36, 1, 1, 13},
+    {37, 1, 1, 13},
+    {39, 1, 1, 14},
+    {40, 1, 1, 14}
+};
+
+const VLCtab2 RvlcDCTtabInter[170] = /* 00xxxx00 or 00xxxx01 */
+{
+    {27, 255, 0, 5},    /* 0000 is escape code */
+    {0, 2, 0, 4},
+    {0, 3, 0, 5},
+    {3, 1, 0, 5},
+    {1, 2, 0, 6},
+    {6, 1, 0, 6},
+    {0, 4, 0, 7},
+    {2, 2, 0, 7},
+    {0, 5, 0, 8},
+    {0, 6, 0, 8},
+    {0, 7, 0, 9},
+    {1, 4, 0, 9},
+    {0, 8, 0, 10},
+    {0, 9, 0, 10},
+    {0, 10, 0, 11},
+    {0, 11, 0, 11},
+    {0, 12, 0, 12},
+    {1, 7, 0, 12},
+    {0, 13, 0, 13},
+    {0, 14, 0, 13},
+    {0, 17, 0, 14},
+    {0, 18, 0, 14},
+    {0, 19, 0, 15},
+    {3, 7, 0, 15},
+    /* 010xxxx00 or 010xxxx01 */
+    {4, 1, 0, 5},
+    {5, 1, 0, 5},
+    {7, 1, 0, 6},
+    {8, 1, 0, 6},
+    {9, 1, 0, 7},
+    {10, 1, 0, 7},
+    {1, 3, 0, 8},
+    {3, 2, 0, 8},
+    {2, 3, 0, 9},
+    {5, 2, 0, 9},
+    {1, 5, 0, 10},
+    {3, 3, 0, 10},
+    {1, 6, 0, 11},
+    {2, 4, 0, 11},
+    {2, 5, 0, 12},
+    {3, 4, 0, 12},
+    {0, 15, 0, 13},
+    {0, 16, 0, 13},
+    {1, 9, 0, 14},
+    {1, 10, 0, 14},
+    {4, 5, 0, 15},
+    {7, 4, 0, 15},
+    /* 0110xxxx00 or 0110xxxx01 */
+    {3, 1, 1, 6},
+    {4, 1, 1, 6},
+    {11, 1, 0, 7},
+    {7, 1, 1, 7},
+    {4, 2, 0, 8},
+    {12, 1, 0, 8},
+    {15, 1, 0, 9},
+    {16, 1, 0, 9},
+    {6, 2, 0, 10},
+    {7, 2, 0, 10},
+    {4, 3, 0, 11},
+    {5, 3, 0, 11},
+    {6, 3, 0, 12},
+    {7, 3, 0, 12},
+    {1, 8, 0, 13},
+    {3, 5, 0, 13},
+    {2, 6, 0, 14},
+    {2, 7, 0, 14},
+    {17, 2, 0, 15},
+    {37, 1, 0, 15},
+    /* 01110xxxx00 or 01110xxxx01 */
+    {8, 1, 1, 7},
+    {9, 1, 1, 7},
+    {13, 1, 0, 8},
+    {14, 1, 0, 8},
+    {17, 1, 0, 9},
+    {1, 2, 1, 9},
+    {8, 2, 0, 10},
+    {9, 2, 0, 10},
+    {10, 2, 0, 11},
+    {21, 1, 0, 11},
+    {11, 2, 0, 12},
+    {27, 1, 0, 12},
+    {4, 4, 0, 13},
+    {5, 4, 0, 13},
+    {3, 6, 0, 14},
+    {6, 4, 0, 14},
+    {38, 1, 0, 15},
+    {1, 5, 1, 15},
+    /* 011110xxxx00 or 011110xxxx01 */
+    {0, 2, 1, 8},
+    {12, 1, 1, 8},
+    {15, 1, 1, 9},
+    {16, 1, 1, 9},
+    {18, 1, 0, 10},
+    {19, 1, 0, 10},
+    {22, 1, 0, 11},
+    {23, 1, 0, 11},
+    {28, 1, 0, 12},
+    {29, 1, 0, 12},
+    {8, 3, 0, 13},
+    {12, 2, 0, 13},
+    {9, 3, 0, 14},
+    {13, 2, 0, 14},
+    {2, 3, 1, 15},
+    {13, 2, 1, 15},
+    /* 0111110xxxx00 or 0111110xxxx01 */
+    {17, 1, 1, 9},
+    {18, 1, 1, 9},
+    {20, 1, 0, 10},
+    {21, 1, 1, 10},
+    {24, 1, 0, 11},
+    {25, 1, 0, 11},
+    {1, 3, 1, 12},
+    {3, 2, 1, 12},
+    {30, 1, 0, 13},
+    {31, 1, 0, 13},
+    {14, 2, 0, 14},
+    {15, 2, 0, 14},
+    {41, 1, 1, 15},
+    {42, 1, 1, 15},
+    /* 01111110xxxx00 or 01111110xxxx01 */
+    {22, 1, 1, 10},
+    {23, 1, 1, 10},
+    {26, 1, 0, 11},
+    {0, 3, 1, 11},
+    {4, 2, 1, 12},
+    {29, 1, 1, 12},
+    {32, 1, 0, 13},
+    {33, 1, 0, 13},
+    {16, 2, 0, 14},
+    {34, 1, 0, 14},
+    {43, 1, 1, 15},
+    {44, 1, 1, 15},
+    /* 011111110xxxx00 or 011111110xxxx01 */
+    {2, 2, 1, 11},
+    {26, 1, 1, 11},
+    {30, 1, 1, 12},
+    {31, 1, 1, 12},
+    {0, 4, 1, 13},
+    {5, 2, 1, 13},
+    {35, 1, 0, 14},
+    {36, 1, 0, 14},
+    /* 0111111110xxxx00 or 0111111110xxxx01 */
+    {32, 1, 1, 12},
+    {33, 1, 1, 12},
+    {6, 2, 1, 13},
+    {7, 2, 1, 13},
+    {0, 5, 1, 14},
+    {1, 4, 1, 14},
+    /* 01111111110xxxx00 or 01111111110xxxx01 */
+    {8, 2, 1, 13},
+    {9, 2, 1, 13},
+    {10, 2, 1, 14},
+    {11, 2, 1, 14},
+    /* 011111111110xxxx00 or 011111111110xxxx01 */
+    {12, 2, 1, 14},
+    {38, 1, 1, 14},
+    /* 1xxxx10 or 1xxxx11 from 11 zeros to 0 zeros*/
+    {0, 1, 0, 3},
+    {1, 1, 0, 3},
+    {2, 1, 0, 4},
+    {0, 1, 1, 4},
+    {1, 1, 1, 5},
+    {2, 1, 1, 5},
+    {5, 1, 1, 6},
+    {6, 1, 1, 6},
+    {10, 1, 1, 7},
+    {11, 1, 1, 7},
+    {13, 1, 1, 8},
+    {14, 1, 1, 8},
+    {19, 1, 1, 9},
+    {20, 1, 1, 9},
+    {24, 1, 1, 10},
+    {25, 1, 1, 10},
+    {27, 1, 1, 11},
+    {28, 1, 1, 11},
+    {34, 1, 1, 12},
+    {35, 1, 1, 12},
+    {36, 1, 1, 13},
+    {37, 1, 1, 13},
+    {39, 1, 1, 14},
+    {40, 1, 1, 14}
+};
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Define all local variables
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Function body here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Return nothing or data or data pointer
+----------------------------------------------------------------------------*/
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/vop.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/vop.cpp
new file mode 100644
index 0000000..74fe478
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/vop.cpp
@@ -0,0 +1,1643 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+#include "mp4dec_lib.h"
+#include "bitstream.h"
+#include "vlc_decode.h"
+#include "zigzag.h"
+
+#define OSCL_DISABLE_WARNING_CONV_POSSIBLE_LOSS_OF_DATA
+
+#ifdef PV_SUPPORT_MAIN_PROFILE
+/* INTRA */
+const static int mpeg_iqmat_def[NCOEFF_BLOCK] =
+{
+    8, 17, 18, 19, 21, 23, 25, 27,
+    17, 18, 19, 21, 23, 25, 27, 28,
+    20, 21, 22, 23, 24, 26, 28, 30,
+    21, 22, 23, 24, 26, 28, 30, 32,
+    22, 23, 24, 26, 28, 30, 32, 35,
+    23, 24, 26, 28, 30, 32, 35, 38,
+    25, 26, 28, 30, 32, 35, 38, 41,
+    27, 28, 30, 32, 35, 38, 41, 45
+};
+
+/* INTER */
+const static int mpeg_nqmat_def[64]  =
+{
+    16, 17, 18, 19, 20, 21, 22, 23,
+    17, 18, 19, 20, 21, 22, 23, 24,
+    18, 19, 20, 21, 22, 23, 24, 25,
+    19, 20, 21, 22, 23, 24, 26, 27,
+    20, 21, 22, 23, 25, 26, 27, 28,
+    21, 22, 23, 24, 26, 27, 28, 30,
+    22, 23, 24, 26, 27, 28, 30, 31,
+    23, 24, 25, 27, 28, 30, 31, 33
+};
+#endif
+
+/* ======================================================================== */
+/*  Function : CalcNumBits()                                                */
+/*  Purpose  :                                                              */
+/*  In/out   :                                                              */
+/*  Return   : Calculate the minimum number of bits required to             */
+/*              represent x.                                                */
+/*  Note     : This is an equivalent implementation of                      */
+/*                      (long)ceil(log((double)x)/log(2.0))                 */
+/*  Modified :                                                              */
+/* ======================================================================== */
+int CalcNumBits(uint x)
+{
+    int i = 1;
+    while (x >>= 1) i++;
+    return i;
+}
+
+
+
+/***********************************************************CommentBegin******
+*
+* -- DecodeVolHeader -- Decode the header of a VOL
+*
+*   04/10/2000 : initial modification to the new PV-Decoder Lib format.
+*   10/12/2001 : reject non compliant bitstreams
+*
+***********************************************************CommentEnd********/
+PV_STATUS DecodeVOLHeader(VideoDecData *video, int layer)
+{
+    PV_STATUS status;
+    Vol *currVol;
+    BitstreamDecVideo *stream;
+    uint32 tmpvar, vol_shape;
+    uint32 startCode;
+#ifdef PV_SUPPORT_MAIN_PROFILE
+    int *qmat, i, j;
+#endif
+    int version_id = 1;
+#ifdef PV_TOLERATE_VOL_ERRORS
+    uint32 profile = 0x01;
+#endif
+    /*  There's a "currLayer" variable inside videoDecData.          */
+    /*   However, we don't maintain it until we decode frame data.  04/05/2000 */
+    currVol = video->vol[layer];
+    stream  = currVol->bitstream;
+    currVol->moduloTimeBase = 0;
+
+    /* Determine which start code for the decoder to begin with */
+    status = BitstreamShowBits32HC(stream, &startCode);
+
+    if (startCode == VISUAL_OBJECT_SEQUENCE_START_CODE)
+    {   /*  Bitstream Exhchange Fix 9/99 */
+        /* Bitstream Exchange requires we allow start with Video Object Sequence */
+        /* visual_object_sequence_start_code            */
+        (void) BitstreamReadBits32HC(stream);
+        tmpvar = (uint32) BitstreamReadBits16(stream,  8); /* profile */
+#ifndef PV_TOLERATE_VOL_ERRORS
+        if (layer)                                                      /*    */
+        {
+            /* support SSPL0-2  */
+            if (tmpvar != 0x10 && tmpvar != 0x11 && tmpvar != 0x12 &&
+                    tmpvar != 0xA1 && tmpvar != 0xA2  && tmpvar != 0xA3/* Core SP@L1-L3 */)
+                return PV_FAIL;
+        }
+        else
+        {
+            /* support SPL0-3 & SSPL0-2   */
+            if (tmpvar != 0x01 && tmpvar != 0x02 && tmpvar != 0x03 && tmpvar != 0x08 &&
+                    tmpvar != 0x10 && tmpvar != 0x11 && tmpvar != 0x12 &&
+                    tmpvar != 0x21 && tmpvar != 0x22 &&  /* Core Profile Levels */
+                    tmpvar != 0xA1 && tmpvar != 0xA2 && tmpvar != 0xA3 &&
+                    tmpvar != 0xF0 && tmpvar != 0xF1 && /* Advanced Simple Profile Levels*/
+                    tmpvar != 0xF2 && tmpvar != 0xF3 &&
+                    tmpvar != 0xF4 && tmpvar != 0xF5)
+                return PV_FAIL;
+        }
+#else
+        profile = tmpvar;
+#endif
+
+        // save the profile and level for the query
+        currVol->profile_level_id = (uint)tmpvar; //  6/10/04
+
+
+
+        status = BitstreamShowBits32HC(stream, &tmpvar);
+        if (tmpvar == USER_DATA_START_CODE)
+        {
+            /* Something has to be done with user data  11/11/99 */
+            status = DecodeUserData(stream);
+            if (status != PV_SUCCESS) return PV_FAIL;
+        }
+        /* visual_object_start_code                     */
+        BitstreamShowBits32HC(stream, &tmpvar);
+        if (tmpvar != VISUAL_OBJECT_START_CODE)
+        {
+            do
+            {
+                /* Search for VOL_HEADER */
+                status = PVSearchNextM4VFrame(stream); /* search 0x00 0x00 0x01 */
+                if (status != PV_SUCCESS) return PV_FAIL; /* breaks the loop */
+                BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
+                PV_BitstreamFlushBits(stream, 8);
+            }
+            while (tmpvar != VOL_START_CODE);
+            goto decode_vol;
+        }
+        else
+        {
+            BitstreamReadBits32HC(stream);
+        }
+
+        /*  is_visual_object_identifier            */
+        tmpvar = (uint32) BitstreamRead1Bits(stream);
+        if (tmpvar)
+        {
+            /* visual_object_verid                            */
+            tmpvar = (uint32) BitstreamReadBits16(stream, 4);
+            /* visual_object_priority                         */
+            tmpvar = (uint32) BitstreamReadBits16(stream, 3);
+        }
+        /* visual_object_type                                 */
+        BitstreamShowBits32(stream, 4, &tmpvar);
+        if (tmpvar == 1)
+        { /* video_signal_type */
+            PV_BitstreamFlushBits(stream, 4);
+            tmpvar = (uint32) BitstreamRead1Bits(stream);
+            if (tmpvar == 1)
+            {
+                /* video_format */
+                tmpvar = (uint32) BitstreamReadBits16(stream, 3);
+                /* video_range  */
+                tmpvar = (uint32) BitstreamRead1Bits(stream);
+                /* color_description */
+                tmpvar = (uint32) BitstreamRead1Bits(stream);
+                if (tmpvar == 1)
+                {
+                    /* color_primaries */
+                    tmpvar = (uint32) BitstreamReadBits16(stream, 8);
+                    /* transfer_characteristics */
+                    tmpvar = (uint32) BitstreamReadBits16(stream, 8);
+                    /* matrix_coefficients */
+                    tmpvar = (uint32) BitstreamReadBits16(stream, 8);
+                }
+            }
+        }
+        else
+        {
+            do
+            {
+                /* Search for VOL_HEADER */
+                status = PVSearchNextM4VFrame(stream); /* search 0x00 0x00 0x01 */
+                if (status != PV_SUCCESS) return PV_FAIL; /* breaks the loop */
+                BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
+                PV_BitstreamFlushBits(stream, 8);
+            }
+            while (tmpvar != VOL_START_CODE);
+            goto decode_vol;
+        }
+
+        /* next_start_code() */
+        status = PV_BitstreamByteAlign(stream);                            /*  10/12/01 */
+        status = BitstreamShowBits32HC(stream, &tmpvar);
+
+        if (tmpvar == USER_DATA_START_CODE)
+        {
+            /* Something has to be done to deal with user data (parse it)  11/11/99 */
+            status = DecodeUserData(stream);
+            if (status != PV_SUCCESS) return PV_FAIL;
+        }
+        status = BitstreamShowBits32(stream, 27, &tmpvar);   /*  10/12/01 */
+    }
+    else
+    {
+        /*      tmpvar = 0;   */                                             /*  10/12/01 */
+        status = BitstreamShowBits32(stream, 27, &tmpvar);     /* uncomment this line if you want
+                                                                     to start decoding with a
+                                                                     video_object_start_code */
+    }
+
+    if (tmpvar == VO_START_CODE)
+    {
+        /*****
+        *
+        *   Read the VOL header entries from the bitstream
+        *
+        *****/
+        /* video_object_start_code                         */
+        tmpvar = BitstreamReadBits32(stream, 27);
+        tmpvar = (uint32) BitstreamReadBits16(stream, 5);
+
+
+        /* video_object_layer_start_code                   */
+        BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
+        if (tmpvar != VOL_START_CODE)
+        {
+            status = BitstreamCheckEndBuffer(stream);
+            if (status == PV_END_OF_VOP)
+            {
+                video->shortVideoHeader = TRUE;
+                return PV_SUCCESS;
+            }
+            else
+            {
+                do
+                {
+                    /* Search for VOL_HEADER */
+                    status = PVSearchNextM4VFrame(stream);/* search 0x00 0x00 0x01 */
+                    if (status != PV_SUCCESS) return PV_FAIL; /* breaks the loop */
+                    BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
+                    PV_BitstreamFlushBits(stream, 8); /* advance the byte ptr */
+                }
+                while (tmpvar != VOL_START_CODE);
+            }
+        }
+        else
+        {
+            PV_BitstreamFlushBits(stream, 8);
+        }
+
+decode_vol:
+        PV_BitstreamFlushBits(stream, VOL_START_CODE_LENGTH - 8);
+        video->shortVideoHeader = 0;
+
+        /* vol_id (4 bits) */
+        currVol->volID = (int) BitstreamReadBits16(stream, 4);
+
+        /* RandomAccessible flag */
+        tmpvar = (uint32) BitstreamRead1Bits(stream);
+
+        /* object type */
+        tmpvar = (uint32) BitstreamReadBits16(stream, 8);                /*  */
+
+#ifdef PV_TOLERATE_VOL_ERRORS
+        if (tmpvar == 0)
+        {
+            if (layer)                                                      /*    */
+            {
+                /* support SSPL0-2  */
+                if (profile != 0x10 && profile != 0x11 && profile != 0x12)
+                    return PV_FAIL;
+                tmpvar = 0x02;
+            }
+            else
+            {
+                /* support SPL0-3 & SSPL0-2   */
+                if (profile != 0x01 && profile != 0x02 && profile != 0x03 && profile != 0x08 &&
+                        profile != 0x10 && profile != 0x11 && profile != 0x12)
+                    return PV_FAIL;
+                tmpvar = 0x01;
+            }
+            profile |= 0x0100;
+        }
+#endif
+
+        if (layer)
+        {
+            if (tmpvar != 0x02) return PV_FAIL;
+        }
+        else
+        {
+            if (tmpvar != 0x01) return PV_FAIL;
+        }
+
+        /* version id specified? */
+        tmpvar = (uint32) BitstreamRead1Bits(stream);
+        if (tmpvar == 1)
+        {
+            /* version ID */
+            version_id = (uint32) BitstreamReadBits16(stream, 4);
+            /* priority */
+            tmpvar = (uint32) BitstreamReadBits16(stream, 3);
+
+        }
+
+        /* aspect ratio info */
+        tmpvar = (uint32) BitstreamReadBits16(stream, 4);
+        if (tmpvar == 0) return PV_FAIL;
+        if (tmpvar == 0xf /* extended_par */)
+        {
+            /* width */
+            tmpvar = (uint32) BitstreamReadBits16(stream, 8);
+            /* height */
+            tmpvar = (uint32) BitstreamReadBits16(stream, 8);
+        }
+
+
+        /* control parameters present? */
+        tmpvar = (uint32) BitstreamRead1Bits(stream);
+
+        /*  Get the parameters (skipped) */
+        /*  03/10/99 */
+        if (tmpvar)
+        {
+            /* chroma_format                    */
+            tmpvar = BitstreamReadBits16(stream, 2);
+            if (tmpvar != 1) return PV_FAIL;
+            /* low_delay  */
+            tmpvar = BitstreamRead1Bits(stream);
+
+            /* vbv_parameters present? */
+            tmpvar = (uint32) BitstreamRead1Bits(stream);
+            if (tmpvar)
+            {
+                /* first_half_bit_rate    */
+                BitstreamReadBits16(stream, 15);
+                if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+                /* latter_half_bit_rate   */
+                BitstreamReadBits16(stream, 15);
+                if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+                /* first_half_vbv_buffer_size   */
+                BitstreamReadBits16(stream, 15);
+                if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+                /* latter_half_vbv_buffer_size   */
+                BitstreamReadBits16(stream,  3);
+                /* first_half_vbv_occupancy     */
+                BitstreamReadBits16(stream, 11);
+                if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+                /* latter_half_vbv_occupancy  */
+                BitstreamReadBits16(stream, 15);
+                if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+            }
+        }
+
+        /* video_object_layer_shape (2 bits), only 00 (rect) is supported for now */
+        vol_shape = (uint32) BitstreamReadBits16(stream, 2);
+        if (vol_shape) return PV_FAIL;
+
+        /* marker bit,  03/10/99 */
+        if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+
+        /* vop_time_increment_resolution   */
+        currVol->timeIncrementResolution = BitstreamReadBits16(stream, 16);
+        if (currVol->timeIncrementResolution == 0) return PV_FAIL;
+
+        /* . since nbitsTimeIncRes will be used over and over again, */
+        /*    we should put it in Vol structure.  04/12/2000.          */
+        currVol->nbitsTimeIncRes = CalcNumBits((uint)currVol->timeIncrementResolution - 1);
+
+        if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+
+        /* fixed_vop_rate */
+        currVol->fixedVopRate = (int) BitstreamRead1Bits(stream);
+        if (currVol->fixedVopRate)
+        {
+            /* fixed_vop_time_increment */
+            tmpvar = BitstreamReadBits16(stream, currVol->nbitsTimeIncRes);
+        }
+
+        /* marker bit */
+        if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+
+        /* video_object_layer_width (13 bits) */
+        video->displayWidth = video->width = (int) BitstreamReadBits16(stream, 13);
+
+        /* round up to a multiple of MB_SIZE.   08/09/2000 */
+        video->width = (video->width + 15) & -16;
+//      video->displayWidth += (video->displayWidth & 0x1);  /* displayed image should be even size */
+
+        /* marker bit */
+        if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+
+        /* video_object_layer_height (13 bits) */
+        video->displayHeight = video->height = (int) BitstreamReadBits16(stream, 13);
+
+        /* round up to a multiple of MB_SIZE.   08/09/2000 */
+        video->height = (video->height + 15) & -16;
+//      video->displayHeight += (video->displayHeight & 0x1); /* displayed image should be even size */
+        if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+
+        /*  03/10/99 */
+        /* interlaced */
+        tmpvar = (uint32) BitstreamRead1Bits(stream);
+        if (tmpvar != 0)
+        {
+            mp4dec_log("DecodeVOLHeader(): Interlaced video is not supported.\n");
+            return PV_FAIL;
+        }
+
+        /* obmc_disable */
+        tmpvar = (uint32) BitstreamRead1Bits(stream);
+        if (tmpvar == 0) return PV_FAIL;
+
+        if (version_id == 1)
+        {
+            /*  sprite_enable (1 bits) */
+            tmpvar = (uint32) BitstreamRead1Bits(stream);
+            if (tmpvar)
+            {
+                mp4dec_log("DecodeVOLHeader(): Sprite is not supported.\n");
+                return PV_FAIL;
+            }
+        }
+        else
+        {
+            /* For version 2, vol_sprite_usage has two bits. */
+            /* sprite_enable */
+            tmpvar = (uint32) BitstreamReadBits16(stream, 2);
+            if (tmpvar)
+            {
+                mp4dec_log("DecodeVOLHeader(): Sprite is not supported.\n");
+                return PV_FAIL;
+            }
+        }
+
+        /* not_8_bit */
+        if (BitstreamRead1Bits(stream))
+        {
+            /* quant_precision */
+            currVol->quantPrecision = BitstreamReadBits16(stream, 4);
+            /* bits_per_pixel  */
+            currVol->bitsPerPixel = BitstreamReadBits16(stream, 4);
+            mp4dec_log("DecodeVOLHeader(): not an 8-bit stream.\n");    // For the time being we do not support != 8 bits
+
+            return PV_FAIL;
+        }
+        else
+        {
+            currVol->quantPrecision = 5;
+            currVol->bitsPerPixel = 8;
+        }
+
+        /* quant_type (1 bit) */
+        currVol->quantType = BitstreamRead1Bits(stream);
+        if (currVol->quantType)
+        {
+#ifdef PV_SUPPORT_MAIN_PROFILE
+            /* load quantization matrices.   5/22/2000 */
+            /* load_intra_quant_mat (1 bit) */
+            qmat = currVol->iqmat;
+            currVol->loadIntraQuantMat = BitstreamRead1Bits(stream);
+            if (currVol->loadIntraQuantMat)
+            {
+                /* intra_quant_mat (8*64 bits) */
+                i = 0;
+                do
+                {
+                    qmat[*(zigzag_inv+i)] = (int) BitstreamReadBits16(stream, 8);
+                }
+                while ((qmat[*(zigzag_inv+i)] != 0) && (++i < 64));
+
+                for (j = i; j < 64; j++)
+                    qmat[*(zigzag_inv+j)] = qmat[*(zigzag_inv+i-1)];
+            }
+            else
+            {
+                oscl_memcpy(qmat, mpeg_iqmat_def, 64*sizeof(int));
+            }
+
+            qmat[0] = 0;             /* necessary for switched && MPEG quant  07/09/01 */
+
+            /* load_nonintra_quant_mat (1 bit) */
+            qmat = currVol->niqmat;
+            currVol->loadNonIntraQuantMat = BitstreamRead1Bits(stream);
+            if (currVol->loadNonIntraQuantMat)
+            {
+                /* nonintra_quant_mat (8*64 bits) */
+                i = 0;
+                do
+                {
+                    qmat[*(zigzag_inv+i)] = (int) BitstreamReadBits16(stream, 8);
+                }
+                while ((qmat[*(zigzag_inv+i)] != 0) && (++i < 64));
+
+                for (j = i; j < 64; j++)
+                    qmat[*(zigzag_inv+j)] = qmat[*(zigzag_inv+i-1)];
+            }
+            else
+            {
+                oscl_memcpy(qmat, mpeg_nqmat_def, 64*sizeof(int));
+            }
+#else
+            return PV_FAIL;
+#endif
+        }
+
+        if (version_id != 1)
+        {
+            /* quarter_sample enabled */
+            tmpvar = BitstreamRead1Bits(stream);
+            if (tmpvar) return PV_FAIL;
+        }
+
+        /* complexity_estimation_disable */
+        currVol->complexity_estDisable = BitstreamRead1Bits(stream);
+        if (currVol->complexity_estDisable == 0)
+        {
+            currVol->complexity_estMethod = BitstreamReadBits16(stream, 2);
+
+            if (currVol->complexity_estMethod < 2)
+            {
+                /* shape_complexity_estimation_disable */
+                tmpvar = BitstreamRead1Bits(stream);
+                if (tmpvar == 0)
+                {
+                    mp4dec_log("DecodeVOLHeader(): Shape Complexity estimation is not supported.\n");
+                    return PV_FAIL;
+                }
+                /* texture_complexity_estimation_set_1_disable */
+                tmpvar = BitstreamRead1Bits(stream);
+                if (tmpvar == 0)
+                {
+                    currVol->complexity.text_1 = BitstreamReadBits16(stream, 4);
+                }
+                /* marker bit */
+                if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+                /* texture_complexity_estimation_set_2_disable */
+                tmpvar = BitstreamRead1Bits(stream);
+                if (tmpvar == 0)
+                {
+                    currVol->complexity.text_2 = BitstreamReadBits16(stream, 4);
+                }
+                /* motion_compensation_complexity_disable */
+                tmpvar = BitstreamRead1Bits(stream);
+                if (tmpvar == 0)
+                {
+                    currVol->complexity.mc = BitstreamReadBits16(stream, 6);
+                }
+                /* marker bit */
+                if (!BitstreamRead1Bits(stream)) return PV_FAIL;
+
+                if (currVol->complexity_estMethod == 1)
+                {   /* version2_complexity_estimation_disable */
+                    tmpvar = BitstreamRead1Bits(stream);
+                    if (tmpvar == 0)
+                    {
+                        mp4dec_log("DecodeVOLHeader(): sadct, quarter pel not supported.\n");
+                        return PV_FAIL;
+                    }
+                }
+            }
+        }
+
+        /*  03/10/99 */
+        /* resync_marker_disable */
+        currVol->errorResDisable = (int) BitstreamRead1Bits(stream);
+        /* data_partititioned    */
+        currVol->dataPartitioning = (int) BitstreamRead1Bits(stream);
+
+        video->vlcDecCoeffIntra = &VlcDecTCOEFIntra;
+        video->vlcDecCoeffInter = &VlcDecTCOEFInter;
+
+        if (currVol->dataPartitioning)
+        {
+            if (layer) return PV_FAIL;                              /*  */
+            /* reversible_vlc */
+            currVol->useReverseVLC = (int)BitstreamRead1Bits(stream);
+            if (currVol->useReverseVLC)
+            {
+                video->vlcDecCoeffIntra = &RvlcDecTCOEFIntra;
+                video->vlcDecCoeffInter = &RvlcDecTCOEFInter;
+            }
+            currVol->errorResDisable = 0;
+        }
+        else
+        {
+            currVol->useReverseVLC = 0;
+        }
+
+        if (version_id != 1)
+        {
+            /* newpred_enable */
+            tmpvar = BitstreamRead1Bits(stream);
+            if (tmpvar) return PV_FAIL;
+
+            /* reduced_resolution_vop */
+            tmpvar = BitstreamRead1Bits(stream);
+            if (tmpvar) return PV_FAIL;
+
+        }
+
+        /* Intra AC/DC prediction is always true */
+        video->intra_acdcPredDisable = 0;
+        /* scalability */
+        currVol->scalability = (int) BitstreamRead1Bits(stream);
+
+        if (currVol->scalability)
+        {
+            if (layer == 0)  return PV_FAIL;                     /*  */
+            /* hierarchy_type: 1 : temporal, 0 : spatial */
+            /*  03/10/99 */
+            currVol->scalType = (int) BitstreamRead1Bits(stream);              /*  */
+            if (!currVol->scalType) return PV_FAIL;
+
+            /* ref_layer_id (4 bits) */
+            currVol->refVolID = (int) BitstreamReadBits16(stream, 4);
+            if (layer)                                                      /*  */
+            {
+                if (currVol->refVolID != video->vol[0]->volID) return PV_FAIL;
+            }
+            /* ref_layer_sampling_direc (1 bits)              */
+            /*   1 : ref. layer has higher resolution         */
+            /*   0 : ref. layer has equal or lower resolution */
+            currVol->refSampDir = (int) BitstreamRead1Bits(stream);
+            if (currVol->refSampDir) return PV_FAIL;
+
+            /* hor_sampling_factor_n (5 bits) */
+            currVol->horSamp_n = (int) BitstreamReadBits16(stream, 5);
+
+            /* hor_sampling_factor_m (5 bits) */
+            currVol->horSamp_m = (int) BitstreamReadBits16(stream, 5);
+
+            if (currVol->horSamp_m == 0) return PV_FAIL;
+            if (currVol->horSamp_n != currVol->horSamp_m) return PV_FAIL;
+
+            /* ver_sampling_factor_n (5 bits) */
+            currVol->verSamp_n = (int) BitstreamReadBits16(stream, 5);
+
+            /* ver_sampling_factor_m (5 bits) */
+            currVol->verSamp_m = (int) BitstreamReadBits16(stream, 5);
+
+            if (currVol->verSamp_m == 0) return PV_FAIL;
+            if (currVol->verSamp_n != currVol->verSamp_m) return PV_FAIL;
+
+
+            /* enhancement_type: 1 : partial region, 0 : full region */
+            /* 04/10/2000: we only support full region enhancement layer. */
+            if (BitstreamRead1Bits(stream)) return PV_FAIL;
+        }
+
+        PV_BitstreamByteAlign(stream);
+
+        status = BitstreamShowBits32HC(stream, &tmpvar);
+
+        /* if we hit the end of buffer, tmpvar == 0.   08/30/2000 */
+        if (tmpvar == USER_DATA_START_CODE)
+        {
+            status = DecodeUserData(stream);
+            /* you should not check for status here  03/19/2002 */
+            status = PV_SUCCESS;
+        }
+
+        /* Compute some convenience variables:   04/13/2000 */
+        video->nMBPerRow = video->width / MB_SIZE;
+        video->nMBPerCol = video->height / MB_SIZE;
+        video->nTotalMB = video->nMBPerRow * video->nMBPerCol;
+        video->nBitsForMBID = CalcNumBits((uint)video->nTotalMB - 1);
+#ifdef PV_ANNEX_IJKT_SUPPORT
+        video->modified_quant = 0;
+        video->advanced_INTRA = 0;
+        video->deblocking = 0;
+        video->slice_structure = 0;
+#endif
+    }
+    else
+    {
+        /* SHORT_HEADER */
+        status = BitstreamShowBits32(stream, SHORT_VIDEO_START_MARKER_LENGTH, &tmpvar);
+
+        if (tmpvar == SHORT_VIDEO_START_MARKER)
+        {
+            video->shortVideoHeader = TRUE;
+        }
+        else
+        {
+            do
+            {
+                /* Search for VOL_HEADER */
+                status = PVSearchNextM4VFrame(stream); /* search 0x00 0x00 0x01 */
+                if (status != PV_SUCCESS) return PV_FAIL; /* breaks the loop */
+                BitstreamShowBits32(stream, VOL_START_CODE_LENGTH, &tmpvar);
+                PV_BitstreamFlushBits(stream, 8);
+            }
+            while (tmpvar != VOL_START_CODE);
+            goto decode_vol;
+        }
+    }
+#ifdef PV_TOLERATE_VOL_ERRORS
+    if (profile > 0xFF || profile == 0)
+    {
+        return PV_BAD_VOLHEADER;
+    }
+#endif
+
+    return status;
+}
+
+
+/***********************************************************CommentBegin******
+*
+* -- DecodeGOV -- Decodes the Group of VOPs from bitstream
+*
+*   04/20/2000  initial modification to the new PV-Decoder Lib format.
+*
+***********************************************************CommentEnd********/
+PV_STATUS DecodeGOVHeader(BitstreamDecVideo *stream, uint32 *time_base)
+{
+    uint32 tmpvar, time_s;
+    int closed_gov, broken_link;
+
+    /* group_start_code (32 bits) */
+//   tmpvar = BitstreamReadBits32(stream, 32);
+
+    /* hours */
+    tmpvar = (uint32) BitstreamReadBits16(stream, 5);
+    time_s = tmpvar * 3600;
+
+    /* minutes */
+    tmpvar = (uint32) BitstreamReadBits16(stream, 6);
+    time_s += tmpvar * 60;
+
+    /* marker bit */
+    tmpvar = (uint32) BitstreamRead1Bits(stream);
+
+    /* seconds */
+    tmpvar = (uint32) BitstreamReadBits16(stream, 6);
+    time_s += tmpvar;
+
+    /* We have to check the timestamp here.  If the sync timestamp is */
+    /*    earlier than the previous timestamp or longer than 60 sec.  */
+    /*    after the previous timestamp, assume the GOV header is      */
+    /*    corrupted.                                 05/12/2000     */
+    *time_base = time_s;   /*  02/27/2002 */
+//  *time_base = *time_base/1000;
+//  tmpvar = time_s - *time_base;
+//  if (tmpvar <= 60) *time_base = time_s;
+//  else return PV_FAIL;
+
+    tmpvar = (uint32) BitstreamRead1Bits(stream);
+    closed_gov = tmpvar;
+    tmpvar = (uint32) BitstreamRead1Bits(stream);
+    broken_link = tmpvar;
+
+    if ((closed_gov == 0) && (broken_link == 1))
+    {
+        return PV_SUCCESS;        /*  03/15/2002  you can also return PV_FAIL */
+    }
+
+    PV_BitstreamByteAlign(stream);
+
+    BitstreamShowBits32HC(stream, &tmpvar);
+
+    while (tmpvar == USER_DATA_START_CODE)       /*  03/15/2002 */
+    {
+        DecodeUserData(stream);
+        BitstreamShowBits32HC(stream, &tmpvar);
+    }
+
+    return PV_SUCCESS;
+}
+
+/***********************************************************CommentBegin******
+*
+* -- DecodeVopHeader -- Decodes the VOPheader information from the bitstream
+*
+*   04/12/2000  Initial port to the new PV decoder library format.
+*   05/10/2000  Error resilient decoding of vop header.
+*
+***********************************************************CommentEnd********/
+PV_STATUS DecodeVOPHeader(VideoDecData *video, Vop *currVop, Bool use_ext_timestamp)
+{
+    PV_STATUS status = PV_SUCCESS;
+    Vol *currVol = video->vol[video->currLayer];
+    BitstreamDecVideo *stream = currVol->bitstream;
+    uint32 tmpvar;
+    int time_base;
+
+    /*****
+    *   Read the VOP header from the bitstream (No shortVideoHeader Mode here!)
+    *****/
+    BitstreamShowBits32HC(stream, &tmpvar);
+
+    /* check if we have a GOV header here.   08/30/2000 */
+    if (tmpvar == GROUP_START_CODE)
+    {
+        tmpvar = BitstreamReadBits32HC(stream);
+//      rewindBitstream(stream, START_CODE_LENGTH); /* for backward compatibility */
+        status = DecodeGOVHeader(stream, &tmpvar);
+        if (status != PV_SUCCESS)
+        {
+            return status;
+        }
+//      use_ext_timestamp = TRUE;   /*  02/08/2002 */
+        /* We should have a VOP header following the GOV header.  03/15/2001 */
+        BitstreamShowBits32HC(stream, &tmpvar);
+    }
+#ifdef PV_SUPPORT_TEMPORAL_SCALABILITY
+    currVop->timeStamp = -1;
+#endif
+    if (tmpvar == VOP_START_CODE)
+    {
+        tmpvar = BitstreamReadBits32HC(stream);
+    }
+    else
+    {
+        PV_BitstreamFlushBits(stream, 8); // advance by a byte
+        status = PV_FAIL;
+        goto return_point;
+    }
+
+
+
+    /* vop_prediction_type (2 bits) */
+    currVop->predictionType = (int) BitstreamReadBits16(stream, 2);
+
+    /* modulo_time_base (? bits) */
+    time_base = -1;
+    do
+    {
+        time_base++;
+        tmpvar = (uint32) BitstreamRead1Bits(stream);
+    }
+    while (tmpvar == 1);
+
+
+
+    if (!use_ext_timestamp)
+    {
+        currVol->moduloTimeBase += 1000 * time_base; /* milliseconds based MTB  11/12/01 */
+    }
+
+    /* marker_bit (1 bit) */
+    if (!BitstreamRead1Bits(stream))
+    {
+        status = PV_FAIL;
+        goto return_point;
+    }
+
+    /* vop_time_increment (1-15 bits) in Nov_Compliant (1-16 bits) */
+    /*    we always assumes fixed vop rate here */
+    currVop->timeInc = BitstreamReadBits16(stream, currVol->nbitsTimeIncRes);
+
+
+    /* marker_bit (1 bit) */
+    if (!BitstreamRead1Bits(stream))
+    {
+        status = PV_FAIL;
+        goto return_point;
+    }
+
+    /* vop_coded */
+    currVop->vopCoded = (int) BitstreamRead1Bits(stream);
+
+
+    if (currVop->vopCoded == 0)
+    {
+        status = PV_SUCCESS;
+        goto return_point;
+    }
+
+
+    /* read vop_rounding_type */
+    if (currVop->predictionType == P_VOP)
+    {
+        currVop->roundingType = (int) BitstreamRead1Bits(stream);
+    }
+    else
+    {
+        currVop->roundingType = 0;
+    }
+
+    if (currVol->complexity_estDisable == 0)
+    {
+        if (currVol->complexity_estMethod < 2)   /*   OCT 2002 */
+        {
+            if ((currVol->complexity.text_1 >> 3) & 0x1)    /* intra        */
+                BitstreamReadBits16(stream, 8);
+            if (currVol->complexity.text_1 & 0x1)           /* not_coded    */
+                BitstreamReadBits16(stream, 8);
+            if ((currVol->complexity.text_2 >> 3) & 0x1)    /* dct_coefs    */
+                BitstreamReadBits16(stream, 8);
+            if ((currVol->complexity.text_2 >> 2) & 0x1)    /* dct_lines    */
+                BitstreamReadBits16(stream, 8);
+            if ((currVol->complexity.text_2 >> 1) & 0x1)    /* vlc_symbols  */
+                BitstreamReadBits16(stream, 8);
+            if (currVol->complexity.text_2 & 0x1)           /* vlc_bits     */
+                BitstreamReadBits16(stream, 4);
+
+            if (currVop->predictionType != I_VOP)
+            {
+                if ((currVol->complexity.text_1 >> 2) & 0x1)    /* inter    */
+                    BitstreamReadBits16(stream, 8);
+                if ((currVol->complexity.text_1 >> 1) & 0x1)    /* inter_4v */
+                    BitstreamReadBits16(stream, 8);
+                if ((currVol->complexity.mc >> 5) & 0x1)        /* apm      */
+                    BitstreamReadBits16(stream, 8);
+                if ((currVol->complexity.mc >> 4) & 0x1)        /* npm      */
+                    BitstreamReadBits16(stream, 8);
+                /* interpolate_mc_q */
+                if ((currVol->complexity.mc >> 2) & 0x1)        /* forw_back_mc_q */
+                    BitstreamReadBits16(stream, 8);
+                if ((currVol->complexity.mc >> 1) & 0x1)        /* halfpel2 */
+                    BitstreamReadBits16(stream, 8);
+                if (currVol->complexity.mc & 0x1)               /* halfpel4 */
+                    BitstreamReadBits16(stream, 8);
+            }
+            if (currVop->predictionType == B_VOP)
+            {
+                if ((currVol->complexity.mc >> 3) & 0x1)        /* interpolate_mc_q */
+                    BitstreamReadBits16(stream, 8);
+            }
+        }
+    }
+
+    /* read intra_dc_vlc_thr */
+    currVop->intraDCVlcThr = (int) BitstreamReadBits16(stream, 3);
+
+    /* read vop_quant (currVol->quantPrecision bits) */
+    currVop->quantizer = (int16) BitstreamReadBits16(stream, currVol->quantPrecision);
+    if (currVop->quantizer == 0)
+    {
+        currVop->quantizer = video->prevVop->quantizer;
+        status = PV_FAIL;
+        goto return_point;
+    }
+
+
+    /* read vop_fcode_forward */
+    if (currVop->predictionType != I_VOP)
+    {
+        tmpvar = (uint32) BitstreamReadBits16(stream, 3);
+        if (tmpvar < 1)
+        {
+            currVop->fcodeForward = 1;
+            status = PV_FAIL;
+            goto return_point;
+        }
+        currVop->fcodeForward = tmpvar;
+    }
+    else
+    {
+        currVop->fcodeForward = 0;
+    }
+
+    /* read vop_fcode_backward */
+    if (currVop->predictionType == B_VOP)
+    {
+        tmpvar = (uint32) BitstreamReadBits16(stream, 3);
+        if (tmpvar < 1)
+        {
+            currVop->fcodeBackward = 1;
+            status = PV_FAIL;
+            goto return_point;
+        }
+        currVop->fcodeBackward = tmpvar;
+    }
+    else
+    {
+        currVop->fcodeBackward = 0;
+    }
+
+    if (currVol->scalability)
+    {
+        currVop->refSelectCode = (int) BitstreamReadBits16(stream, 2);
+    }
+
+return_point:
+    return status;
+}
+
+
+/***********************************************************CommentBegin******
+*
+* -- VideoPlaneWithShortHeader -- Decodes the short_video_header information from the bitstream
+* Modified :
+             04/23/2001.  Remove the codes related to the
+                 "first pass" decoding.  We use a different function
+                 to set up the decoder now.
+***********************************************************CommentEnd********/
+PV_STATUS DecodeShortHeader(VideoDecData *video, Vop *currVop)
+{
+    PV_STATUS status = PV_SUCCESS;
+    Vol *currVol = video->vol[0];
+    BitstreamDecVideo *stream = currVol->bitstream;
+    uint32 tmpvar;
+    int32 size;
+
+    int extended_PTYPE = FALSE;
+    int UFEP = 0, custom_PFMT = 0, custom_PCF = 0;
+
+    status = BitstreamShowBits32(stream, SHORT_VIDEO_START_MARKER_LENGTH, &tmpvar);
+
+    if (tmpvar !=  SHORT_VIDEO_START_MARKER)
+    {
+        status = PV_FAIL;
+        goto return_point;
+    }
+
+
+    PV_BitstreamFlushBits(stream, SHORT_VIDEO_START_MARKER_LENGTH);
+
+    /* Temporal reference. Using vop_time_increment_resolution = 30000 */
+    tmpvar = (uint32) BitstreamReadBits16(stream, 8);
+    currVop->temporalRef = (int) tmpvar;
+
+
+    currVop->timeInc = 0xff & (256 + currVop->temporalRef - video->prevVop->temporalRef);
+    currVol->moduloTimeBase += currVop->timeInc; /* mseconds   11/12/01 */
+    /* Marker Bit */
+    if (!BitstreamRead1Bits(stream))
+    {
+        mp4dec_log("DecodeShortHeader(): Market bit wrong.\n");
+        status = PV_FAIL;
+        goto return_point;
+    }
+
+    /* Zero Bit */
+    if (BitstreamRead1Bits(stream))
+    {
+        mp4dec_log("DecodeShortHeader(): Zero bit wrong.\n");
+        status = PV_FAIL;
+        goto return_point;
+    }
+
+    /*split_screen_indicator*/
+    if (BitstreamRead1Bits(stream))
+    {
+        mp4dec_log("DecodeShortHeader(): Split Screen not supported.\n");
+        VideoDecoderErrorDetected(video);
+    }
+
+    /*document_freeze_camera*/
+    if (BitstreamRead1Bits(stream))
+    {
+        mp4dec_log("DecodeShortHeader(): Freeze Camera not supported.\n");
+        VideoDecoderErrorDetected(video);
+    }
+
+    /*freeze_picture_release*/
+    if (BitstreamRead1Bits(stream))
+    {
+        mp4dec_log("DecodeShortHeader(): Freeze Release not supported.\n");
+        VideoDecoderErrorDetected(video);
+    }
+    /* source format */
+    switch (BitstreamReadBits16(stream, 3))
+    {
+        case 1:
+            if (video->size < 128*96)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            video->displayWidth = video->width =  128;
+            video->displayHeight = video->height  = 96;
+            break;
+
+        case 2:
+            if (video->size < 176*144)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            video->displayWidth = video->width  = 176;
+            video->displayHeight = video->height  = 144;
+            break;
+
+        case 3:
+            if (video->size < 352*288)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            video->displayWidth = video->width = 352;
+            video->displayHeight = video->height = 288;
+            break;
+
+        case 4:
+            if (video->size < 704*576)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            video->displayWidth = video->width = 704;
+            video->displayHeight = video->height = 576;
+            break;
+
+        case 5:
+            if (video->size < 1408*1152)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            video->displayWidth = video->width = 1408;
+            video->displayHeight = video->height = 1152;
+            break;
+
+        case 7:
+            extended_PTYPE = TRUE;
+            break;
+
+        default:
+            /* Msg("H.263 source format not legal\n"); */
+            status = PV_FAIL;
+            goto return_point;
+    }
+
+
+    currVop->roundingType = 0;
+
+    if (extended_PTYPE == FALSE)
+    {
+        currVop->predictionType = (int) BitstreamRead1Bits(stream);
+
+        /* four_reserved_zero_bits */
+        if (BitstreamReadBits16(stream, 4))
+        {
+            mp4dec_log("DecodeShortHeader(): Reserved bits wrong.\n");
+            status = PV_FAIL;
+            goto return_point;
+        }
+    }
+    else
+    {
+        UFEP = BitstreamReadBits16(stream, 3);
+        if (UFEP == 1)
+        {
+            /* source format */
+            switch (BitstreamReadBits16(stream, 3))
+            {
+                case 1:
+                    if (video->size < 128*96)
+                    {
+                        status = PV_FAIL;
+                        goto return_point;
+                    }
+                    video->displayWidth = video->width =  128;
+                    video->displayHeight = video->height  = 96;
+                    break;
+
+                case 2:
+                    if (video->size < 176*144)
+                    {
+                        status = PV_FAIL;
+                        goto return_point;
+                    }
+                    video->displayWidth = video->width  = 176;
+                    video->displayHeight = video->height  = 144;
+                    break;
+
+                case 3:
+                    if (video->size < 352*288)
+                    {
+                        status = PV_FAIL;
+                        goto return_point;
+                    }
+                    video->displayWidth = video->width = 352;
+                    video->displayHeight = video->height = 288;
+                    break;
+
+                case 4:
+                    if (video->size < 704*576)
+                    {
+                        status = PV_FAIL;
+                        goto return_point;
+                    }
+                    video->displayWidth = video->width = 704;
+                    video->displayHeight = video->height = 576;
+                    break;
+
+                case 5:
+                    if (video->size < 1408*1152)
+                    {
+                        status = PV_FAIL;
+                        goto return_point;
+                    }
+                    video->displayWidth = video->width = 1408;
+                    video->displayHeight = video->height = 1152;
+                    break;
+
+                case 6:
+                    custom_PFMT = TRUE;
+                    break;
+
+                default:
+                    /* Msg("H.263 source format not legal\n"); */
+                    status = PV_FAIL;
+                    goto return_point;
+            }
+
+            custom_PCF = BitstreamRead1Bits(stream);
+            /* unrestricted MV */
+            if (BitstreamRead1Bits(stream))
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            /* SAC */
+            if (BitstreamRead1Bits(stream))
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+
+            /* AP */
+            if (BitstreamRead1Bits(stream))
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+
+            video->advanced_INTRA = BitstreamRead1Bits(stream);
+
+            video->deblocking = BitstreamRead1Bits(stream);
+
+            video->slice_structure = BitstreamRead1Bits(stream);
+
+            /* RPS, ISD, AIV */
+            if (BitstreamReadBits16(stream, 3))
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            video->modified_quant = BitstreamRead1Bits(stream);
+
+            /* Marker Bit and reserved*/
+            if (BitstreamReadBits16(stream, 4) != 8)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+        }
+#ifndef PV_ANNEX_IJKT_SUPPORT
+        if (video->advanced_INTRA | video->deblocking | video->modified_quant | video->modified_quant)
+        {
+            status = PV_FAIL;
+            goto return_point;
+        }
+#endif
+
+        if (UFEP == 0 || UFEP == 1)
+        {
+            tmpvar = BitstreamReadBits16(stream, 3);
+            if (tmpvar > 1)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            currVop->predictionType = tmpvar;
+            /* RPR */
+            if (BitstreamRead1Bits(stream))
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+
+            /* RRU */
+            if (BitstreamRead1Bits(stream))
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            currVop->roundingType = (int) BitstreamRead1Bits(stream);
+            if (BitstreamReadBits16(stream, 3) != 1)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+        }
+        else
+        {
+            status = PV_FAIL;
+            goto return_point;
+        }
+        /* CPM */
+        if (BitstreamRead1Bits(stream))
+        {
+            status = PV_FAIL;
+            goto return_point;
+        }
+        /* CPFMT */
+        if (custom_PFMT == 1 && UFEP == 1)
+        {
+            /* aspect ratio */
+            tmpvar = BitstreamReadBits16(stream, 4);
+            if (tmpvar == 0)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            /* Extended PAR */
+            if (tmpvar == 0xF)
+            {
+                /* Read par_width and par_height but do nothing */
+                /* par_width */
+                tmpvar = BitstreamReadBits16(stream, 8);
+
+                /* par_height */
+                tmpvar = BitstreamReadBits16(stream, 8);
+            }
+            tmpvar = BitstreamReadBits16(stream, 9);
+
+            video->displayWidth = (tmpvar + 1) << 2;
+            video->width = (video->displayWidth + 15) & -16;
+            /* marker bit */
+            if (!BitstreamRead1Bits(stream))
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            tmpvar = BitstreamReadBits16(stream, 9);
+            if (tmpvar == 0)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+            video->displayHeight = tmpvar << 2;
+            video->height = (video->displayHeight + 15) & -16;
+
+            if (video->height * video->width > video->size)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+
+            video->nTotalMB = video->width / MB_SIZE * video->height / MB_SIZE;
+
+            if (video->nTotalMB <= 48)
+            {
+                video->nBitsForMBID = 6;
+            }
+            else if (video->nTotalMB <= 99)
+            {
+                video->nBitsForMBID = 7;
+            }
+            else if (video->nTotalMB <= 396)
+            {
+                video->nBitsForMBID = 9;
+            }
+            else if (video->nTotalMB <= 1584)
+            {
+                video->nBitsForMBID = 11;
+            }
+            else if (video->nTotalMB <= 6336)
+            {
+                video->nBitsForMBID = 13 ;
+            }
+            else if (video->nTotalMB <= 9216)
+            {
+                video->nBitsForMBID = 14 ;
+            }
+            else
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+        }
+        if (UFEP == 1 && custom_PCF == 1)
+        {
+            BitstreamRead1Bits(stream);
+
+            tmpvar = BitstreamReadBits16(stream, 7);
+            if (tmpvar == 0)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+        }
+
+        if (custom_PCF == 1)
+        {
+            currVop->ETR = BitstreamReadBits16(stream, 2);
+        }
+
+        if (UFEP == 1 && video->slice_structure == 1)
+        {
+            /* SSS */
+            tmpvar = BitstreamReadBits16(stream, 2);
+            if (tmpvar != 0)
+            {
+                status = PV_FAIL;
+                goto return_point;
+            }
+        }
+    }
+
+    /* Recalculate number of macroblocks per row & col since */
+    /*  the frame size can change.           04/23/2001.   */
+    video->nMBinGOB = video->nMBPerRow = video->width / MB_SIZE;
+    video->nGOBinVop = video->nMBPerCol = video->height / MB_SIZE;
+    video->nTotalMB = video->nMBPerRow * video->nMBPerCol;
+    if (custom_PFMT == 0  || UFEP == 0)
+    {
+        video->nBitsForMBID = CalcNumBits((uint)video->nTotalMB - 1); /* otherwise calculate above */
+    }
+    size = (int32)video->width * video->height;
+    if (video->currVop->predictionType == P_VOP && size > video->videoDecControls->size)
+    {
+        status = PV_FAIL;
+        goto return_point;
+    }
+    video->videoDecControls->size = size;
+    video->currVop->uChan = video->currVop->yChan + size;
+    video->currVop->vChan = video->currVop->uChan + (size >> 2);
+    video->prevVop->uChan = video->prevVop->yChan + size;
+    video->prevVop->vChan = video->prevVop->uChan + (size >> 2);
+
+
+    currVop->quantizer = (int16) BitstreamReadBits16(stream, 5);
+
+    if (currVop->quantizer == 0)                          /*  04/03/01 */
+    {
+        currVop->quantizer = video->prevVop->quantizer;
+        status = PV_FAIL;
+        goto return_point;
+    }
+
+
+    /* Zero bit */
+    if (extended_PTYPE == FALSE)
+    {
+        if (BitstreamRead1Bits(stream))
+        {
+            mp4dec_log("DecodeShortHeader(): Zero bit wrong.\n");
+            status = PV_FAIL;
+            goto return_point;
+        }
+    }
+    /* pei */
+    tmpvar = (uint32) BitstreamRead1Bits(stream);
+
+    while (tmpvar)
+    {
+        tmpvar = (uint32) BitstreamReadBits16(stream, 8); /* "PSPARE" */
+        tmpvar = (uint32) BitstreamRead1Bits(stream); /* "PEI" */
+    }
+
+    if (video->slice_structure)  /* ANNEX_K */
+    {
+        if (!BitstreamRead1Bits(stream))  /* SEPB1 */
+        {
+            status = PV_FAIL;
+            goto return_point;
+        }
+
+        //  if (currVol->nBitsForMBID //
+        if (BitstreamReadBits16(stream, video->nBitsForMBID))
+        {
+            status = PV_FAIL;             /* no ASO, RS support for Annex K */
+            goto return_point;
+        }
+
+        if (!BitstreamRead1Bits(stream))  /*SEPB3 */
+        {
+            status = PV_FAIL;
+            goto return_point;
+        }
+
+    }
+    /* Setting of other VOP-header parameters */
+    currVop->gobNumber = 0;
+    currVop->vopCoded = 1;
+
+    currVop->intraDCVlcThr = 0;
+    currVop->gobFrameID = 0; /* initial value,  05/22/00 */
+    currVol->errorResDisable = 0;
+    /*PutVopInterlaced(0,curr_vop); no implemented yet */
+    if (currVop->predictionType != I_VOP)
+        currVop->fcodeForward = 1;
+    else
+        currVop->fcodeForward = 0;
+
+return_point:
+
+    return status;
+}
+/***********************************************************CommentBegin******
+*
+* -- PV_DecodeVop -- Decodes the VOP information from the bitstream
+*
+*   04/12/2000
+*                   Initial port to the new PV decoder library format.
+*                   This function is different from the one in MoMuSys MPEG-4
+*                   visual decoder.  We handle combined mode with or withput
+*                   error resilience and H.263 mode through the sam path now.
+*
+*   05/04/2000
+*                   Added temporal scalability to the decoder.
+*
+***********************************************************CommentEnd********/
+PV_STATUS PV_DecodeVop(VideoDecData *video)
+{
+    Vol *currVol = video->vol[video->currLayer];
+    PV_STATUS status;
+    uint32 tmpvar;
+
+    /*****
+    *   Do scalable or non-scalable decoding of the current VOP
+    *****/
+
+    if (!currVol->scalability)
+    {
+        if (currVol->dataPartitioning)
+        {
+            /* Data partitioning mode comes here */
+            status = DecodeFrameDataPartMode(video);
+        }
+        else
+        {
+            /* Combined mode with or without error resilience */
+            /*    and short video header comes here.          */
+            status = DecodeFrameCombinedMode(video);
+        }
+    }
+    else
+    {
+#ifdef DO_NOT_FOLLOW_STANDARD
+        /* according to the standard, only combined mode is allowed */
+        /*    in the enhancement layer.          06/01/2000.        */
+        if (currVol->dataPartitioning)
+        {
+            /* Data partitioning mode comes here */
+            status = DecodeFrameDataPartMode(video);
+        }
+        else
+        {
+            /* Combined mode with or without error resilience */
+            /*    and short video header comes here.          */
+            status = DecodeFrameCombinedMode(video);
+        }
+#else
+        status = DecodeFrameCombinedMode(video);
+#endif
+    }
+
+    /* This part is for consuming Visual_object_sequence_end_code and EOS Code */   /*  10/15/01 */
+    if (!video->shortVideoHeader)
+    {
+        /* at this point bitstream is expected to be byte aligned */
+        BitstreamByteAlignNoForceStuffing(currVol->bitstream);
+
+        status = BitstreamShowBits32HC(currVol->bitstream, &tmpvar);  /*  07/07/01 */
+        if (tmpvar == VISUAL_OBJECT_SEQUENCE_END_CODE)/* VOS_END_CODE */
+        {
+            PV_BitstreamFlushBits(currVol->bitstream, 16);
+            PV_BitstreamFlushBits(currVol->bitstream, 16);
+        }
+
+    }
+    else
+    {
+#ifdef PV_ANNEX_IJKT_SUPPORT
+        if (video->deblocking)
+        {
+            H263_Deblock(video->currVop->yChan, video->width, video->height, video->QPMB, video->headerInfo.Mode, 0, 0);
+            H263_Deblock(video->currVop->uChan, video->width >> 1, video->height >> 1, video->QPMB, video->headerInfo.Mode, 1, video->modified_quant);
+            H263_Deblock(video->currVop->vChan, video->width >> 1, video->height >> 1, video->QPMB, video->headerInfo.Mode, 1, video->modified_quant);
+        }
+#endif
+        /* Read EOS code for shortheader bitstreams    */
+        status = BitstreamShowBits32(currVol->bitstream, 22, &tmpvar);
+        if (tmpvar == SHORT_VIDEO_END_MARKER)
+        {
+            PV_BitstreamFlushBits(currVol->bitstream, 22);
+        }
+        else
+        {
+            status = PV_BitstreamShowBitsByteAlign(currVol->bitstream, 22, &tmpvar);
+            if (tmpvar == SHORT_VIDEO_END_MARKER)
+            {
+                PV_BitstreamByteAlign(currVol->bitstream);
+                PV_BitstreamFlushBits(currVol->bitstream, 22);
+            }
+        }
+    }
+    return status;
+}
+
+
+/***********************************************************CommentBegin******
+*
+* -- CalcVopDisplayTime -- calculate absolute time when VOP is to be displayed
+*
+*   04/12/2000 Initial port to the new PV decoder library format.
+*
+***********************************************************CommentEnd********/
+uint32 CalcVopDisplayTime(Vol *currVol, Vop *currVop, int shortVideoHeader)
+{
+    uint32 display_time;
+
+
+    /*****
+    *   Calculate the time when the VOP is to be displayed next
+    *****/
+
+    if (!shortVideoHeader)
+    {
+        display_time = (uint32)(currVol->moduloTimeBase + (((int32)currVop->timeInc - (int32)currVol->timeInc_offset) * 1000) / ((int32)currVol->timeIncrementResolution));  /*  11/12/2001 */
+        if (currVop->timeStamp >= display_time)
+        {
+            display_time += 1000;  /* this case is valid if GOVHeader timestamp is ignored */
+        }
+    }
+    else
+    {
+        display_time = (uint32)(currVol->moduloTimeBase * 33 + (currVol->moduloTimeBase * 11) / 30); /*  11/12/2001 */
+    }
+
+    return(display_time);
+}
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/zigzag.h b/media/libstagefright/codecs/m4v_h263/dec/src/zigzag.h
new file mode 100644
index 0000000..4690a18
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/zigzag.h
@@ -0,0 +1,72 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+
+#ifndef zigzag_H
+#define zigzag_H
+
+/*----------------------------------------------------------------------------
+; INCLUDES
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; EXTERNAL VARIABLES REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    extern const int zigzag_inv[3*NCOEFF_BLOCK];
+    /*----------------------------------------------------------------------------
+    ; SIMPLE TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; ENUMERATED TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; STRUCTURES TYPEDEF'S
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; GLOBAL FUNCTION DEFINITIONS
+    ; Function Prototype declaration
+    ----------------------------------------------------------------------------*/
+
+    /*----------------------------------------------------------------------------
+    ; END
+    ----------------------------------------------------------------------------*/
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/zigzag_tab.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/zigzag_tab.cpp
new file mode 100644
index 0000000..33dbb14
--- /dev/null
+++ b/media/libstagefright/codecs/m4v_h263/dec/src/zigzag_tab.cpp
@@ -0,0 +1,110 @@
+/* ------------------------------------------------------------------
+ * Copyright (C) 1998-2009 PacketVideo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ * -------------------------------------------------------------------
+ */
+
+#include    "mp4dec_api.h"
+#include    "mp4def.h"
+#include    "zigzag.h"
+/*----------------------------------------------------------------------------
+; MACROS
+; Define module specific macros here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; DEFINES
+; Include all pre-processor statements here. Include conditional
+; compile variables also.
+----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+; LOCAL FUNCTION DEFINITIONS
+; Function Prototype declaration
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; LOCAL STORE/BUFFER/POINTER DEFINITIONS
+; Variable declaration - defined here and used outside this module
+----------------------------------------------------------------------------*/
+const int zigzag_inv[3*NCOEFF_BLOCK] =
+{
+    0,  1,  8, 16,  9,  2,  3, 10,
+    17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63,
+//};
+
+    /* Vertical inverse zigzag */
+//const static Int zigzag_v_inv[NCOEFF_BLOCK] = {
+    0, 8, 16, 24, 1, 9, 2, 10,
+    17, 25, 32, 40, 48, 56, 57, 49,
+    41, 33, 26, 18, 3, 11, 4, 12,
+    19, 27, 34, 42, 50, 58, 35, 43,
+    51, 59, 20, 28, 5, 13, 6, 14,
+    21, 29, 36, 44, 52, 60, 37, 45,
+    53, 61, 22, 30, 7, 15, 23, 31,
+    38, 46, 54, 62, 39, 47, 55, 63,
+//};
+    /* Horizontal inverse zigzag*/
+//const static Int zizag_h_inv[NCOEFF_BLOCK] = {
+    0, 1, 2, 3, 8, 9, 16, 17,
+    10, 11, 4, 5, 6, 7, 15, 14,
+    13, 12, 19, 18, 24, 25, 32, 33,
+    26, 27, 20, 21, 22, 23, 28, 29,
+    30, 31, 34, 35, 40, 41, 48, 49,
+    42, 43, 36, 37, 38, 39, 44, 45,
+    46, 47, 50, 51, 56, 57, 58, 59,
+    52, 53, 54, 55, 60, 61, 62, 63
+};
+
+/*----------------------------------------------------------------------------
+; EXTERNAL FUNCTION REFERENCES
+; Declare functions defined elsewhere and referenced in this module
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
+; Declare variables used in this module but defined elsewhere
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; FUNCTION CODE
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Define all local variables
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Function body here
+----------------------------------------------------------------------------*/
+
+
+/*----------------------------------------------------------------------------
+; Return nothing or data or data pointer
+----------------------------------------------------------------------------*/
+
+