Fix H.264 8x8 transform selection
[ffmpeg.git] / libavcodec / huffyuv.c
index 2fcb9ef..f68d8e7 100644 (file)
@@ -3,19 +3,21 @@
  *
  * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
  *
- * This library is free software; you can redistribute it and/or
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
  *
- * This library is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  *
  * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
  * the algorithm used
@@ -72,7 +74,7 @@ typedef struct HYuvContext{
     VLC vlc[3];
     AVFrame picture;
     uint8_t *bitstream_buffer;
-    int bitstream_buffer_size;
+    unsigned int bitstream_buffer_size;
     DSPContext dsp;
 }HYuvContext;
 
@@ -204,6 +206,29 @@ static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src
     }
 }
 
+static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
+    int i;
+    int r,g,b;
+    r= *red;
+    g= *green;
+    b= *blue;
+    for(i=0; i<FFMIN(w,4); i++){
+        const int rt= src[i*4+R];
+        const int gt= src[i*4+G];
+        const int bt= src[i*4+B];
+        dst[i*4+R]= rt - r;
+        dst[i*4+G]= gt - g;
+        dst[i*4+B]= bt - b;
+        r = rt;
+        g = gt;
+        b = bt;
+    }
+    s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
+    *red=   src[(w-1)*4+R];
+    *green= src[(w-1)*4+G];
+    *blue=  src[(w-1)*4+B];
+}
+
 static void read_len_table(uint8_t *dst, GetBitContext *gb){
     int i, val, repeat;
 
@@ -236,6 +261,7 @@ static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
     return 0;
 }
 
+#ifdef CONFIG_ENCODERS
 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
     uint64_t counts[2*size];
     int up[2*size];
@@ -291,6 +317,7 @@ static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
         if(i==size) break;
     }
 }
+#endif /* CONFIG_ENCODERS */
 
 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
     GetBitContext gb;
@@ -343,7 +370,7 @@ static int read_old_huffman_tables(HYuvContext *s){
 
     return 0;
 #else
-    fprintf(stderr, "v1 huffyuv is not supported \n");
+    av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
     return -1;
 #endif
 }
@@ -356,7 +383,9 @@ static void alloc_temp(HYuvContext *s){
             s->temp[i]= av_malloc(s->width + 16);
         }
     }else{
-        s->temp[0]= av_malloc(4*s->width + 16);
+        for(i=0; i<2; i++){
+            s->temp[i]= av_malloc(4*s->width + 16);
+        }
     }
 }
 
@@ -375,6 +404,7 @@ static int common_init(AVCodecContext *avctx){
     return 0;
 }
 
+#ifdef CONFIG_DECODERS
 static int decode_init(AVCodecContext *avctx)
 {
     HYuvContext *s = avctx->priv_data;
@@ -447,7 +477,7 @@ s->bgr32=1;
         break;
     case 16:
         if(s->yuy2){
-            avctx->pix_fmt = PIX_FMT_YUV422;
+            avctx->pix_fmt = PIX_FMT_YUYV422;
         }else{
             avctx->pix_fmt = PIX_FMT_YUV422P;
         }
@@ -455,7 +485,7 @@ s->bgr32=1;
     case 24:
     case 32:
         if(s->bgr32){
-            avctx->pix_fmt = PIX_FMT_RGBA32;
+            avctx->pix_fmt = PIX_FMT_RGB32;
         }else{
             avctx->pix_fmt = PIX_FMT_BGR24;
         }
@@ -470,7 +500,9 @@ s->bgr32=1;
 
     return 0;
 }
+#endif
 
+#ifdef CONFIG_ENCODERS
 static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
     int i;
     int index= 0;
@@ -514,6 +546,9 @@ static int encode_init(AVCodecContext *avctx)
     case PIX_FMT_YUV422P:
         s->bitstream_bpp= 16;
         break;
+    case PIX_FMT_RGB32:
+        s->bitstream_bpp= 24;
+        break;
     default:
         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
         return -1;
@@ -541,12 +576,14 @@ static int encode_init(AVCodecContext *avctx)
         }
         if(s->interlaced != ( s->height > 288 ))
             av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
-    }else if(avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
-        av_log(avctx, AV_LOG_ERROR, "This codec is under development; files encoded with it may not be decodable with future versions!!! Set vstrict=-2 / -strict -2 to use it anyway.\n");
+    }
+
+    if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
+        av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
         return -1;
     }
 
-    ((uint8_t*)avctx->extradata)[0]= s->predictor;
+    ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
     ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
     ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
     if(s->context)
@@ -615,6 +652,7 @@ static int encode_init(AVCodecContext *avctx)
 
     return 0;
 }
+#endif /* CONFIG_ENCODERS */
 
 static void decode_422_bitstream(HYuvContext *s, int count){
     int i;
@@ -640,6 +678,7 @@ static void decode_gray_bitstream(HYuvContext *s, int count){
     }
 }
 
+#ifdef CONFIG_ENCODERS
 static int encode_422_bitstream(HYuvContext *s, int count){
     int i;
 
@@ -714,6 +753,7 @@ static int encode_gray_bitstream(HYuvContext *s, int count){
     }
     return 0;
 }
+#endif /* CONFIG_ENCODERS */
 
 static void decode_bgr_bitstream(HYuvContext *s, int count){
     int i;
@@ -751,6 +791,49 @@ static void decode_bgr_bitstream(HYuvContext *s, int count){
     }
 }
 
+static int encode_bgr_bitstream(HYuvContext *s, int count){
+    int i;
+
+    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
+        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
+        return -1;
+    }
+
+    if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
+        for(i=0; i<count; i++){
+            int g= s->temp[0][4*i+G];
+            int b= (s->temp[0][4*i+B] - g) & 0xff;
+            int r= (s->temp[0][4*i+R] - g) & 0xff;
+            s->stats[0][b]++;
+            s->stats[1][g]++;
+            s->stats[2][r]++;
+        }
+    }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
+        for(i=0; i<count; i++){
+            int g= s->temp[0][4*i+G];
+            int b= (s->temp[0][4*i+B] - g) & 0xff;
+            int r= (s->temp[0][4*i+R] - g) & 0xff;
+            s->stats[0][b]++;
+            s->stats[1][g]++;
+            s->stats[2][r]++;
+            put_bits(&s->pb, s->len[1][g], s->bits[1][g]);
+            put_bits(&s->pb, s->len[0][b], s->bits[0][b]);
+            put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
+        }
+    }else{
+        for(i=0; i<count; i++){
+            int g= s->temp[0][4*i+G];
+            int b= (s->temp[0][4*i+B] - g) & 0xff;
+            int r= (s->temp[0][4*i+R] - g) & 0xff;
+            put_bits(&s->pb, s->len[1][g], s->bits[1][g]);
+            put_bits(&s->pb, s->len[0][b], s->bits[0][b]);
+            put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
+        }
+    }
+    return 0;
+}
+
+#ifdef CONFIG_DECODERS
 static void draw_slice(HYuvContext *s, int y){
     int h, cy;
     int offset[4];
@@ -808,6 +891,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8
             return -1;
     }
 
+    if((unsigned)(buf_size-table_size) >= INT_MAX/8)
+        return -1;
+
     init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
 
     fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
@@ -1012,8 +1098,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8
     *picture= *p;
     *data_size = sizeof(AVFrame);
 
-    return (get_bits_count(&s->gb)+31)/32*4;
+    return (get_bits_count(&s->gb)+31)/32*4 + table_size;
 }
+#endif
 
 static int common_end(HYuvContext *s){
     int i;
@@ -1024,6 +1111,7 @@ static int common_end(HYuvContext *s){
     return 0;
 }
 
+#ifdef CONFIG_DECODERS
 static int decode_end(AVCodecContext *avctx)
 {
     HYuvContext *s = avctx->priv_data;
@@ -1038,7 +1126,9 @@ static int decode_end(AVCodecContext *avctx)
 
     return 0;
 }
+#endif
 
+#ifdef CONFIG_ENCODERS
 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
     HYuvContext *s = avctx->priv_data;
     AVFrame *pict = data;
@@ -1174,6 +1264,31 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
                 encode_422_bitstream(s, width);
             }
         }
+    }else if(avctx->pix_fmt == PIX_FMT_RGB32){
+        uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
+        const int stride = -p->linesize[0];
+        const int fake_stride = -fake_ystride;
+        int y;
+        int leftr, leftg, leftb;
+
+        put_bits(&s->pb, 8, leftr= data[R]);
+        put_bits(&s->pb, 8, leftg= data[G]);
+        put_bits(&s->pb, 8, leftb= data[B]);
+        put_bits(&s->pb, 8, 0);
+
+        sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
+        encode_bgr_bitstream(s, width-1);
+
+        for(y=1; y<s->height; y++){
+            uint8_t *dst = data + y*stride;
+            if(s->predictor == PLANE && s->interlaced < y){
+                s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
+                sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
+            }else{
+                sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
+            }
+            encode_bgr_bitstream(s, width);
+        }
     }else{
         av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
     }
@@ -1218,7 +1333,9 @@ static int encode_end(AVCodecContext *avctx)
 
     return 0;
 }
+#endif /* CONFIG_ENCODERS */
 
+#ifdef CONFIG_DECODERS
 AVCodec huffyuv_decoder = {
     "huffyuv",
     CODEC_TYPE_VIDEO,
@@ -1244,6 +1361,7 @@ AVCodec ffvhuff_decoder = {
     CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
     NULL
 };
+#endif
 
 #ifdef CONFIG_ENCODERS
 
@@ -1255,6 +1373,7 @@ AVCodec huffyuv_encoder = {
     encode_init,
     encode_frame,
     encode_end,
+    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
 };
 
 AVCodec ffvhuff_encoder = {
@@ -1265,6 +1384,7 @@ AVCodec ffvhuff_encoder = {
     encode_init,
     encode_frame,
     encode_end,
+    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
 };
 
 #endif //CONFIG_ENCODERS