Merge remote-tracking branch 'qatar/master'

[ffmpeg] / libavcodec / ffv1.c

diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index b9b36dcf94253914f21df82394b36cfa8924b169..540dfdb51f1888c5256c6d124f12d07715ce540a 100644 (file)
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -660,9 +660,8 @@ static void write_header(FFV1Context *f){
         put_rac(c, state, f->transparency);
 
         write_quant_tables(c, f->quant_table);
-    }else{
+    }else if(f->version < 3){
         put_symbol(c, state, f->slice_count, 0);
-        if(f->version < 3){
         for(i=0; i<f->slice_count; i++){
             FFV1Context *fs= f->slice_context[i];
             put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
@@ -674,7 +673,6 @@ static void write_header(FFV1Context *f){
                 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
             }
         }
-        }
     }
 }
 #endif /* CONFIG_FFV1_ENCODER */
@@ -1102,7 +1100,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
                     goto slices_ok;
             }
         }
-        av_log(avctx, AV_LOG_ERROR, "Unsupported number %d of slices requested\n", avctx->slices);
+        av_log(avctx, AV_LOG_ERROR, "Unsupported number %d of slices requested, please specify a supported number with -slices (ex:4,6,9,12,16, ...)\n", avctx->slices);
         return -1;
         slices_ok:
         write_extra_header(s);
@@ -1157,15 +1155,6 @@ static void clear_slice_state(FFV1Context *f, FFV1Context *fs){
         }
 }
 
-static void clear_state(FFV1Context *f){
-    int si;
-
-    for(si=0; si<f->slice_count; si++){
-        FFV1Context *fs= f->slice_context[si];
-        clear_slice_state(f, fs);
-    }
-}
-
 #if CONFIG_FFV1_ENCODER
 
 static void encode_slice_header(FFV1Context *f, FFV1Context *fs){
@@ -1198,6 +1187,8 @@ static int encode_slice(AVCodecContext *c, void *arg){
     AVFrame * const p= &f->picture;
     const int ps= (f->bits_per_raw_sample>8)+1;
 
+    if(p->key_frame)
+        clear_slice_state(f, fs);
     if(f->version > 2){
         encode_slice_header(f, fs);
     }
@@ -1254,7 +1245,6 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         p->key_frame= 1;
         f->gob_count++;
         write_header(f);
-        clear_state(f);
     }else{
         put_rac(c, &keystate, 0);
         p->key_frame= 0;
@@ -1290,15 +1280,17 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
             flush_put_bits(&fs->pb); //nicer padding FIXME
             bytes= fs->ac_byte_count + (put_bits_count(&fs->pb)+7)/8;
         }
-        if(i>0){
+        if(i>0 || f->version>2){
             av_assert0(bytes < pkt->size/f->slice_count);
-            memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
+            memmove(buf_p, fs->c.bytestream_start, bytes);
             av_assert0(bytes < (1<<24));
             AV_WB24(buf_p+bytes, bytes);
             bytes+=3;
         }
         if(f->ec){
-            unsigned v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
+            unsigned v;
+            buf_p[bytes++] = 0;
+            v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);
             AV_WL32(buf_p + bytes, v); bytes += 4;
         }
         buf_p += bytes;
@@ -1601,12 +1593,13 @@ static int decode_slice(AVCodecContext *c, void *arg){
     AVFrame * const p= &f->picture;
 
     if(f->version > 2){
-        if(decode_slice_header(f, fs) < 0)
-            return AVERROR_INVALIDDATA;
-
         if(init_slice_state(f, fs) < 0)
             return AVERROR(ENOMEM);
+        if(decode_slice_header(f, fs) < 0)
+            return AVERROR_INVALIDDATA;
     }
+    if(init_slice_state(f, fs) < 0)
+        return AVERROR(ENOMEM);
     if(f->picture.key_frame)
         clear_slice_state(f, fs);
     width = fs->slice_width;
@@ -1614,6 +1607,13 @@ static int decode_slice(AVCodecContext *c, void *arg){
     x= fs->slice_x;
     y= fs->slice_y;
 
+    if(!fs->ac){
+        fs->ac_byte_count = f->version > 2 || (!x&&!y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
+        init_get_bits(&fs->gb,
+                      fs->c.bytestream_start + fs->ac_byte_count,
+                      (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8);
+    }
+
     av_assert1(width && height);
     if(f->colorspace==0){
         const int chroma_width = -((-width )>>f->chroma_h_shift);
@@ -1853,10 +1853,21 @@ static int read_header(FFV1Context *f){
                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
                 return -1;
         }
-    }else{
+    }else if(f->version < 3){
         f->slice_count= get_symbol(c, state, 0);
-        if(f->slice_count > (unsigned)MAX_SLICES)
-            return -1;
+    }else{
+        const uint8_t *p= c->bytestream_end;
+        for(f->slice_count = 0; f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start; f->slice_count++){
+            int trailer = 3 + 5*!!f->ec;
+            int size = AV_RB24(p-trailer);
+            if(size + trailer > p - c->bytestream_start)
+                break;
+            p -= size + trailer;
+        }
+    }
+    if(f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0){
+        av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid\n", f->slice_count);
+        return -1;
     }
 
     for(j=0; j<f->slice_count; j++){
@@ -1898,11 +1909,11 @@ static int read_header(FFV1Context *f){
             }
 
             if(f->version <= 2){
-            if(p->context_count < context_count){
-                av_freep(&p->state);
-                av_freep(&p->vlc_state);
-            }
-            p->context_count= context_count;
+                if(p->context_count < context_count){
+                    av_freep(&p->state);
+                    av_freep(&p->vlc_state);
+                }
+                p->context_count= context_count;
             }
         }
     }
@@ -1950,8 +1961,6 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
         f->key_frame_ok = 0;
         if(read_header(f) < 0)
             return -1;
-        if(init_slices_state(f) < 0)
-            return -1;
         f->key_frame_ok = 1;
     }else{
         if (!f->key_frame_ok) {
@@ -1960,13 +1969,6 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
         }
         p->key_frame= 0;
     }
-    if(f->ac>1){
-        int i;
-        for(i=1; i<256; i++){
-            c->one_state[i]= f->state_transition[i];
-            c->zero_state[256-i]= 256-c->one_state[i];
-        }
-    }
 
     p->reference= 0;
     if(avctx->get_buffer(avctx, p) < 0){
@@ -1980,11 +1982,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
     buf_p= buf + buf_size;
     for(i=f->slice_count-1; i>=0; i--){
         FFV1Context *fs= f->slice_context[i];
-        int trailer = 3 + 4*!!f->ec;
+        int trailer = 3 + 5*!!f->ec;
         int v;
 
-        if(i) v = AV_RB24(buf_p-trailer)+trailer;
-        else  v = buf_p - c->bytestream_start;
+        if(i || f->version>2) v = AV_RB24(buf_p-trailer)+trailer;
+        else                  v = buf_p - c->bytestream_start;
         if(buf_p - c->bytestream_start < v){
             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
             return -1;
@@ -1999,17 +2001,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
         }
 
         if(i){
-            if(fs->ac){
-                ff_init_range_decoder(&fs->c, buf_p, v);
-            }else{
-                init_get_bits(&fs->gb, buf_p, v * 8);
-            }
-        }else{
-            if(!f->ac){
-                bytes_read = c->bytestream - c->bytestream_start - 1;
-                if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
-                init_get_bits(&fs->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
-            }
+            ff_init_range_decoder(&fs->c, buf_p, v);
         }
     }