Index: libavcodec/h264.c
===================================================================
--- libavcodec/h264.c	(revision 15936)
+++ libavcodec/h264.c	(working copy)
@@ -86,6 +86,66 @@
 #endif
 }
 
+static void inline zero(uint8_t *src, int stride, int width, int height){
+    int i, j;
+    for(i=0; i<height; i++){
+        for(j=0; j<width; j++){
+            src[j]=0;
+        }
+        src+= stride;
+    }
+}
+
+static void inline pred4x4_predictive_vertical_c(uint8_t *src, int stride){
+    int i;
+    for(i=0; i<4; i++){
+        src[0] += src[0-stride];
+        src[1] += src[1-stride];
+        src[2] += src[2-stride];
+        src[3] += src[3-stride];
+        src+= stride;
+    }
+}
+
+static void inline pred4x4_predictive_horizontal_c(uint8_t *src, int stride){
+    int i;
+    for(i=0; i<4; i++){
+        src[stride*0] += src[stride*0-1];
+        src[stride*1] += src[stride*1-1];
+        src[stride*2] += src[stride*2-1];
+        src[stride*3] += src[stride*3-1];
+        src++;
+    }
+}
+
+static void inline pred8x8_predictive_vertical_c(uint8_t *src, int stride){
+    pred4x4_predictive_vertical_c(src, stride);
+    pred4x4_predictive_vertical_c(src+4, stride);
+    pred4x4_predictive_vertical_c(src+stride*4, stride);
+    pred4x4_predictive_vertical_c(src+stride*4+4, stride);
+}
+
+static void inline pred8x8_predictive_horizontal_c(uint8_t *src, int stride){
+    pred4x4_predictive_horizontal_c(src, stride);
+    pred4x4_predictive_horizontal_c(src+stride*4, stride);
+    pred4x4_predictive_horizontal_c(src+4, stride);
+    pred4x4_predictive_horizontal_c(src+stride*4+4, stride);
+}
+
+static void pred16x16_predictive_vertical_c(uint8_t *src, int stride){
+    pred8x8_predictive_vertical_c(src, stride);
+    pred8x8_predictive_vertical_c(src+8, stride);
+    pred8x8_predictive_vertical_c(src+stride*8, stride);
+    pred8x8_predictive_vertical_c(src+stride*8+8, stride);
+}
+
+static void pred16x16_predictive_horizontal_c(uint8_t *src, int stride){
+    pred8x8_predictive_horizontal_c(src, stride);
+    pred8x8_predictive_horizontal_c(src+stride*8, stride);
+    pred8x8_predictive_horizontal_c(src+8, stride);
+    pred8x8_predictive_horizontal_c(src+stride*8+8, stride);
+}
+ 
 static const uint8_t rem6[52]={
 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
 };
@@ -2513,8 +2573,16 @@
                 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);
 
             if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
-                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
-                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
+                if(transform_bypass && h->sps.profile_idc == 244 && (h->chroma_pred_mode == VERT_PRED8x8 || h->chroma_pred_mode == HOR_PRED8x8))
+                {
+                    zero(dest_cb, uvlinesize, 8, 8);
+                    zero(dest_cr, uvlinesize, 8, 8);
+                }
+                else
+                {
+                    h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
+                    h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
+                }
             }
 
             if(IS_INTRA4x4(mb_type)){
@@ -2524,14 +2592,25 @@
                             uint8_t * const ptr= dest_y + block_offset[i];
                             const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
                             const int nnz = h->non_zero_count_cache[ scan8[i] ];
-                            h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
-                                                   (h->topright_samples_available<<i)&0x4000, linesize);
-                            if(nnz){
-                                if(nnz == 1 && h->mb[i*16])
-                                    idct_dc_add(ptr, h->mb + i*16, linesize);
-                                else
-                                    idct_add(ptr, h->mb + i*16, linesize);
+                            if(transform_bypass && h->sps.profile_idc == 244 && (dir == VERT_PRED || dir == HOR_PRED)){
+                                zero(ptr, linesize, 8, 8);
+                                idct_add(ptr, h->mb + i*16, linesize);
+                                if( dir == VERT_PRED )
+                                    pred8x8_predictive_vertical_c(ptr, linesize);
+                                else if( dir == HOR_PRED )
+                                    pred8x8_predictive_horizontal_c(ptr, linesize);
                             }
+                            else
+                            {
+                                h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
+                                                       (h->topright_samples_available<<i)&0x4000, linesize);
+                                if(nnz){
+                                    if(nnz == 1 && h->mb[i*16])
+                                        idct_dc_add(ptr, h->mb + i*16, linesize);
+                                    else
+                                        idct_add(ptr, h->mb + i*16, linesize);
+                                }
+                            }
                         }
                     }else
                     for(i=0; i<16; i++){
@@ -2551,21 +2630,35 @@
                         }else
                             topright= NULL;
 
-                        h->hpc.pred4x4[ dir ](ptr, topright, linesize);
-                        nnz = h->non_zero_count_cache[ scan8[i] ];
-                        if(nnz){
-                            if(is_h264){
-                                if(nnz == 1 && h->mb[i*16])
-                                    idct_dc_add(ptr, h->mb + i*16, linesize);
-                                else
-                                    idct_add(ptr, h->mb + i*16, linesize);
-                            }else
-                                svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
+                        if(transform_bypass && h->sps.profile_idc == 244 && (dir == VERT_PRED || dir == HOR_PRED)){
+                            zero(ptr, linesize, 4, 4);
+                            idct_add(ptr, h->mb + i*16, linesize);
+                            if( dir == VERT_PRED )
+                                pred4x4_predictive_vertical_c(ptr, linesize);
+                            else if( dir == HOR_PRED )
+                                pred4x4_predictive_horizontal_c(ptr, linesize);
                         }
+                        else
+                        {
+                            h->hpc.pred4x4[ dir ](ptr, topright, linesize);
+                            nnz = h->non_zero_count_cache[ scan8[i] ];
+                            if(nnz){
+                                if(is_h264){
+                                    if(nnz == 1 && h->mb[i*16])
+                                        idct_dc_add(ptr, h->mb + i*16, linesize);
+                                    else
+                                        idct_add(ptr, h->mb + i*16, linesize);
+                                }else
+                                    svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
+                            }
+                        }
                     }
                 }
             }else{
-                h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
+                if(transform_bypass && h->sps.profile_idc == 244 && (h->intra16x16_pred_mode == VERT_PRED8x8 || h->intra16x16_pred_mode == HOR_PRED8x8))
+                    zero(dest_y, linesize, 16, 16);
+                else
+                    h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
                 if(is_h264){
                     if(!transform_bypass)
                         h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[0][s->qscale][0]);
@@ -2591,6 +2684,12 @@
                         else if(h->mb[i*16])
                             idct_dc_add(dest_y + block_offset[i], h->mb + i*16, linesize);
                     }
+                    if(transform_bypass && h->sps.profile_idc == 244 && (h->intra16x16_pred_mode == VERT_PRED8x8 || h->intra16x16_pred_mode == HOR_PRED8x8)){
+                        if( h->intra16x16_pred_mode == VERT_PRED8x8 )
+                            pred16x16_predictive_vertical_c(dest_y, linesize);
+                        else if( h->intra16x16_pred_mode == HOR_PRED8x8 )
+                            pred16x16_predictive_horizontal_c(dest_y, linesize);
+                    }
                 }else{
                     const int di = IS_8x8DCT(mb_type) ? 4 : 1;
                     for(i=0; i<16; i+=di){
@@ -2630,6 +2729,18 @@
                     else if(h->mb[i*16])
                         idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
                 }
+                if(transform_bypass && IS_INTRA(mb_type) && h->sps.profile_idc == 244 && (h->chroma_pred_mode == VERT_PRED8x8 || h->chroma_pred_mode == HOR_PRED8x8)){
+                    if( h->chroma_pred_mode == VERT_PRED8x8 )
+                    {
+                        pred8x8_predictive_vertical_c(dest[0], uvlinesize);
+                        pred8x8_predictive_vertical_c(dest[1], uvlinesize);
+                    }
+                    else if( h->chroma_pred_mode == HOR_PRED8x8 )
+                    {
+                        pred8x8_predictive_horizontal_c(dest[0], uvlinesize);
+                        pred8x8_predictive_horizontal_c(dest[1], uvlinesize);
+                    }
+                }
             }else{
                 for(i=16; i<16+8; i++){
                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){