*
* Copyright (c) 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
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
*/
/**
* FF Video Codec 1 (an experimental lossless codec)
*/
-#include "common.h"
-#include "bitstream.h"
#include "avcodec.h"
+#include "bitstream.h"
#include "dsputil.h"
#include "rangecoder.h"
#include "golomb.h"
#define MAX_PLANES 4
#define CONTEXT_SIZE 32
+extern const uint8_t ff_log2_run[32];
+
static const int8_t quant3[256]={
0, 0, 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,
-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
};
-static const uint8_t log2_run[32]={
- 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
- 4, 4, 5, 5, 6, 6, 7, 7,
- 8, 9,10,11,12,13,14,15,
-};
-
typedef struct VlcState{
int16_t drift;
uint16_t error_sum;
DSPContext dsp;
}FFV1Context;
-static always_inline int fold(int diff, int bits){
+static av_always_inline int fold(int diff, int bits){
if(bits==8)
diff= (int8_t)diff;
else{
int i;
if(v){
- const int a= ABS(v);
+ const int a= FFABS(v);
const int e= av_log2(a);
put_rac(c, state+0, 0);
static inline void update_vlc_state(VlcState * const state, const int v){
int drift= state->drift;
int count= state->count;
- state->error_sum += ABS(v);
+ state->error_sum += FFABS(v);
drift += v;
if(count == 128){ //FIXME variable
return ret;
}
+#ifdef CONFIG_FFV1_ENCODER
static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
PlaneContext * const p= &s->plane[plane_index];
RangeCoder * const c= &s->c;
if(run_mode){
if(diff){
- while(run_count >= 1<<log2_run[run_index]){
- run_count -= 1<<log2_run[run_index];
+ while(run_count >= 1<<ff_log2_run[run_index]){
+ run_count -= 1<<ff_log2_run[run_index];
run_index++;
put_bits(&s->pb, 1, 1);
}
- put_bits(&s->pb, 1 + log2_run[run_index], run_count);
+ put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
if(run_index) run_index--;
run_count=0;
run_mode=0;
}
}
if(run_mode){
- while(run_count >= 1<<log2_run[run_index]){
- run_count -= 1<<log2_run[run_index];
+ while(run_count >= 1<<ff_log2_run[run_index]){
+ run_count -= 1<<ff_log2_run[run_index];
run_index++;
put_bits(&s->pb, 1, 1);
}
for(i=0; i<5; i++)
write_quant_table(c, f->quant_table[i]);
}
+#endif /* CONFIG_FFV1_ENCODER */
-static int common_init(AVCodecContext *avctx){
+static av_cold int common_init(AVCodecContext *avctx){
FFV1Context *s = avctx->priv_data;
int width, height;
return 0;
}
-static int encode_init(AVCodecContext *avctx)
+#ifdef CONFIG_FFV1_ENCODER
+static av_cold int encode_init(AVCodecContext *avctx)
{
FFV1Context *s = avctx->priv_data;
int i;
- 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 decodeable with future versions!!!\n"
- "use vstrict=-2 / -strict -2 to use it anyway\n");
- return -1;
- }
-
common_init(avctx);
s->version=0;
case PIX_FMT_YUV410P:
s->colorspace= 0;
break;
- case PIX_FMT_RGBA32:
+ case PIX_FMT_RGB32:
s->colorspace= 1;
break;
default:
return 0;
}
+#endif /* CONFIG_FFV1_ENCODER */
static void clear_state(FFV1Context *f){
}
}
+#ifdef CONFIG_FFV1_ENCODER
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
FFV1Context *f = avctx->priv_data;
RangeCoder * const c= &f->c;
return used_count + (put_bits_count(&f->pb)+7)/8;
}
}
+#endif /* CONFIG_FFV1_ENCODER */
-static void common_end(FFV1Context *s){
+static av_cold int common_end(AVCodecContext *avctx){
+ FFV1Context *s = avctx->priv_data;
int i;
for(i=0; i<s->plane_count; i++){
PlaneContext *p= &s->plane[i];
av_freep(&p->state);
+ av_freep(&p->vlc_state);
}
-}
-
-static int encode_end(AVCodecContext *avctx)
-{
- FFV1Context *s = avctx->priv_data;
-
- common_end(s);
return 0;
}
if(run_mode){
if(run_count==0 && run_mode==1){
if(get_bits1(&s->gb)){
- run_count = 1<<log2_run[run_index];
+ run_count = 1<<ff_log2_run[run_index];
if(x + run_count <= w) run_index++;
}else{
- if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
+ if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
else run_count=0;
if(run_index) run_index--;
run_mode=2;
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
int x, y;
int_fast16_t sample_buffer[2][w+6];
- int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
+ int_fast16_t *sample[2];
+ sample[0]=sample_buffer[0]+3;
+ sample[1]=sample_buffer[1]+3;
s->run_index=0;
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
int x, y, p;
int_fast16_t sample_buffer[3][2][w+6];
- int_fast16_t *sample[3][2]= {
- {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
- {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
- {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
+ int_fast16_t *sample[3][2];
+ for(x=0; x<3; x++){
+ sample[x][0] = sample_buffer[x][0]+3;
+ sample[x][1] = sample_buffer[x][1]+3;
+ }
s->run_index=0;
av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
return -1;
}
- f->avctx->pix_fmt= PIX_FMT_RGBA32;
+ f->avctx->pix_fmt= PIX_FMT_RGB32;
}else{
av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
return -1;
return 0;
}
-static int decode_init(AVCodecContext *avctx)
+static av_cold int decode_init(AVCodecContext *avctx)
{
// FFV1Context *s = avctx->priv_data;
return 0;
}
-static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
+static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){
FFV1Context *f = avctx->priv_data;
RangeCoder * const c= &f->c;
const int width= f->width;
p->pict_type= FF_I_TYPE; //FIXME I vs. P
if(get_rac(c, &keystate)){
p->key_frame= 1;
- read_header(f);
+ if(read_header(f) < 0)
+ return -1;
clear_state(f);
}else{
p->key_frame= 0;
}
+ if(!f->plane[0].state && !f->plane[0].vlc_state)
+ return -1;
p->reference= 0;
if(avctx->get_buffer(avctx, p) < 0){
sizeof(FFV1Context),
decode_init,
NULL,
- NULL,
+ common_end,
decode_frame,
CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
- NULL
+ NULL,
+ .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
};
-#ifdef CONFIG_ENCODERS
+#ifdef CONFIG_FFV1_ENCODER
AVCodec ffv1_encoder = {
"ffv1",
CODEC_TYPE_VIDEO,
sizeof(FFV1Context),
encode_init,
encode_frame,
- encode_end,
+ common_end,
+ .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_NONE},
+ .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
};
#endif