]> git.sesse.net Git - ffmpeg/blobdiff - libavcodec/ffv1.c
projects / ffmpeg / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
lavc/vda: fix make checkheaders.
[ffmpeg] / libavcodec / ffv1.c
diff --git a/libavcodec/ffv1.c b/libavcodec/ffv1.c
index 8680e76105165caac47aa2d0bb830bff9fea44c7..32eab5144176efc22e51750316359abfd3fcbf22 100644 (file)
--- a/libavcodec/ffv1.c
+++ b/libavcodec/ffv1.c
@@ -36,6 +36,7 @@
 #include "libavutil/pixdesc.h"
 #include "libavutil/avassert.h"
 #include "libavutil/crc.h"
+#include "libavutil/opt.h"
 
 #ifdef __INTEL_COMPILER
 #undef av_flatten
@@ -164,6 +165,7 @@ typedef struct PlaneContext{
 #define MAX_SLICES 256
 
 typedef struct FFV1Context{
+    AVClass *class;
     AVCodecContext *avctx;
     RangeCoder c;
     GetBitContext gb;
@@ -660,9 +662,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 +675,6 @@ static void write_header(FFV1Context *f){
                 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
             }
         }
-        }
     }
 }
 #endif /* CONFIG_FFV1_ENCODER */
@@ -905,7 +905,10 @@ static av_cold int encode_init(AVCodecContext *avctx)
 
     if(avctx->level == 3){
         s->version = 3;
-        s->ec = 1;
+    }
+
+    if(s->ec < 0){
+        s->ec = (s->version >= 3);
     }
 
     if(s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
@@ -961,6 +964,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
         s->colorspace= 0;
         break;
     case PIX_FMT_YUVA444P:
+    case PIX_FMT_YUVA422P:
     case PIX_FMT_YUVA420P:
         s->chroma_planes= 1;
         s->colorspace= 0;
@@ -1102,7 +1106,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 +1161,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 +1193,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 +1251,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,7 +1286,7 @@ 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->c.bytestream_start, bytes);
             av_assert0(bytes < (1<<24));
@@ -1298,7 +1294,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
             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 +1599,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;
@@ -1806,6 +1805,7 @@ static int read_header(FFV1Context *f){
         }else if(f->avctx->bits_per_raw_sample<=8 && f->transparency){
             switch(16*f->chroma_h_shift + f->chroma_v_shift){
             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUVA444P; break;
+            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUVA422P; break;
             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUVA420P; break;
             default:
                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
@@ -1860,10 +1860,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++){
@@ -1905,11 +1916,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;
             }
         }
     }
@@ -1937,7 +1948,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
     FFV1Context *f = avctx->priv_data;
     RangeCoder * const c= &f->slice_context[0]->c;
     AVFrame * const p= &f->picture;
-    int bytes_read, i;
+    int i;
     uint8_t keystate= 128;
     const uint8_t *buf_p;
 
@@ -1957,8 +1968,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) {
@@ -1967,13 +1976,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){
@@ -1987,11 +1989,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;
@@ -2033,6 +2035,21 @@ AVCodec ff_ffv1_decoder = {
 };
 
 #if CONFIG_FFV1_ENCODER
+
+#define OFFSET(x) offsetof(FFV1Context, x)
+#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+static const AVOption options[] = {
+    { "slicecrc",        "Protect slices with CRCs",               OFFSET(ec),              AV_OPT_TYPE_INT, {-1}, -1, 1, VE},
+{NULL}
+};
+
+static const AVClass class = {
+    .class_name = "ffv1 encoder",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
 AVCodec ff_ffv1_encoder = {
     .name           = "ffv1",
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -2044,5 +2061,6 @@ AVCodec ff_ffv1_encoder = {
     .capabilities   = CODEC_CAP_SLICE_THREADS,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUVA420P, PIX_FMT_YUV444P, PIX_FMT_YUVA444P, PIX_FMT_YUV440P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_0RGB32, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV444P9, PIX_FMT_YUV422P9, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_YUV444P10, PIX_FMT_GRAY16, PIX_FMT_GRAY8, PIX_FMT_NONE},
     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
+    .priv_class     = &class,
 };
 #endif
Unnamed repository; edit this file 'description' to name the repository.