*
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * 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.1 of the License, or (at your option) any later version.
*
- * Libav 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 Libav; 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
*/
*/
#include "avcodec.h"
+#include "internal.h"
#include "get_bits.h"
#include "put_bits.h"
#include "dsputil.h"
#include "rangecoder.h"
#include "golomb.h"
#include "mathops.h"
+#include "libavutil/pixdesc.h"
#include "libavutil/avassert.h"
#define MAX_PLANES 4
int version;
int width, height;
int chroma_h_shift, chroma_v_shift;
+ int chroma_planes;
+ int transparency;
int flags;
int picture_number;
AVFrame picture;
int colorspace;
int16_t *sample_buffer;
int gob_count;
+ int packed_at_lsb;
int quant_table_count;
int slice_height;
int slice_x;
int slice_y;
+ int bits_per_raw_sample;
}FFV1Context;
static av_always_inline int fold(int diff, int bits){
sample[0][-1]= sample[1][0 ];
sample[1][ w]= sample[1][w-1];
//{START_TIMER
- if(s->avctx->bits_per_raw_sample<=8){
+ if(s->bits_per_raw_sample<=8){
for(x=0; x<w; x++){
sample[0][x]= src[x + stride*y];
}
encode_line(s, w, sample, plane_index, 8);
}else{
- for(x=0; x<w; x++){
- sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
+ if(s->packed_at_lsb){
+ for(x=0; x<w; x++){
+ sample[0][x]= ((uint16_t*)(src + stride*y))[x];
+ }
+ }else{
+ for(x=0; x<w; x++){
+ sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);
+ }
}
- encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
+ encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);
}
//STOP_TIMER("encode line")}
}
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
int x, y, p, i;
const int ring_size= s->avctx->context_model ? 3 : 2;
- int16_t *sample[3][3];
+ int16_t *sample[4][3];
s->run_index=0;
- memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
+ memset(s->sample_buffer, 0, ring_size*4*(w+6)*sizeof(*s->sample_buffer));
for(y=0; y<h; y++){
for(i=0; i<ring_size; i++)
- for(p=0; p<3; p++)
+ for(p=0; p<4; p++)
sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
for(x=0; x<w; x++){
- int v= src[x + stride*y];
+ unsigned v= src[x + stride*y];
int b= v&0xFF;
int g= (v>>8)&0xFF;
int r= (v>>16)&0xFF;
+ int a= v>>24;
b -= g;
r -= g;
sample[0][0][x]= g;
sample[1][0][x]= b;
sample[2][0][x]= r;
+ sample[3][0][x]= a;
}
- for(p=0; p<3; p++){
+ for(p=0; p<3 + s->transparency; p++){
sample[p][0][-1]= sample[p][1][0 ];
sample[p][1][ w]= sample[p][1][w-1];
- encode_line(s, w, sample[p], FFMIN(p, 1), 9);
+ encode_line(s, w, sample[p], (p+1)/2, 9);
}
}
}
}
put_symbol(c, state, f->colorspace, 0); //YUV cs type
if(f->version>0)
- put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
- put_rac(c, state, 1); //chroma planes
- put_symbol(c, state, f->chroma_h_shift, 0);
- put_symbol(c, state, f->chroma_v_shift, 0);
- put_rac(c, state, 0); //no transparency plane
+ put_symbol(c, state, f->bits_per_raw_sample, 0);
+ put_rac(c, state, f->chroma_planes);
+ put_symbol(c, state, f->chroma_h_shift, 0);
+ put_symbol(c, state, f->chroma_v_shift, 0);
+ put_rac(c, state, f->transparency);
write_quant_tables(c, f->quant_table);
}else{
s->avctx= avctx;
s->flags= avctx->flags;
+ avcodec_get_frame_defaults(&s->picture);
+
ff_dsputil_init(&s->dsp, avctx);
s->width = avctx->width;
for(i=0; i<f->slice_count; i++){
FFV1Context *fs= f->slice_context[i];
+ fs->plane_count= f->plane_count;
+ fs->transparency= f->transparency;
for(j=0; j<f->plane_count; j++){
PlaneContext * const p= &fs->plane[j];
fs->slice_x = sxs;
fs->slice_y = sys;
- fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
+ fs->sample_buffer = av_malloc(3*4 * (fs->width+6) * sizeof(*fs->sample_buffer));
if (!fs->sample_buffer)
return AVERROR(ENOMEM);
}
}
}
put_symbol(c, state, f->colorspace, 0); //YUV cs type
- put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
- put_rac(c, state, 1); //chroma planes
- put_symbol(c, state, f->chroma_h_shift, 0);
- put_symbol(c, state, f->chroma_v_shift, 0);
- put_rac(c, state, 0); //no transparency plane
+ put_symbol(c, state, f->bits_per_raw_sample, 0);
+ put_rac(c, state, f->chroma_planes);
+ put_symbol(c, state, f->chroma_h_shift, 0);
+ put_symbol(c, state, f->chroma_v_shift, 0);
+ put_rac(c, state, f->transparency);
put_symbol(c, state, f->num_h_slices-1, 0);
put_symbol(c, state, f->num_v_slices-1, 0);
for(i=1; i<256; i++)
s->state_transition[i]=ver2_state[i];
- s->plane_count=2;
+ s->plane_count=3;
+ switch(avctx->pix_fmt){
+ case PIX_FMT_YUV444P9:
+ case PIX_FMT_YUV422P9:
+ case PIX_FMT_YUV420P9:
+ if (!avctx->bits_per_raw_sample)
+ s->bits_per_raw_sample = 9;
+ case PIX_FMT_YUV444P10:
+ case PIX_FMT_YUV420P10:
+ case PIX_FMT_YUV422P10:
+ s->packed_at_lsb = 1;
+ if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
+ s->bits_per_raw_sample = 10;
+ case PIX_FMT_GRAY16:
+ case PIX_FMT_YUV444P16:
+ case PIX_FMT_YUV422P16:
+ case PIX_FMT_YUV420P16:
+ if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
+ s->bits_per_raw_sample = 16;
+ } else if (!s->bits_per_raw_sample){
+ s->bits_per_raw_sample = avctx->bits_per_raw_sample;
+ }
+ if(s->bits_per_raw_sample <=8){
+ av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
+ return -1;
+ }
+ if(!s->ac){
+ av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
+ return -1;
+ }
+ s->version= FFMAX(s->version, 1);
+ case PIX_FMT_GRAY8:
+ case PIX_FMT_YUV444P:
+ case PIX_FMT_YUV440P:
+ case PIX_FMT_YUV422P:
+ case PIX_FMT_YUV420P:
+ case PIX_FMT_YUV411P:
+ case PIX_FMT_YUV410P:
+ s->chroma_planes= av_pix_fmt_descriptors[avctx->pix_fmt].nb_components < 3 ? 0 : 1;
+ s->colorspace= 0;
+ break;
+ case PIX_FMT_YUVA444P:
+ case PIX_FMT_YUVA420P:
+ s->chroma_planes= 1;
+ s->colorspace= 0;
+ s->transparency= 1;
+ break;
+ case PIX_FMT_RGB32:
+ s->colorspace= 1;
+ s->transparency= 1;
+ break;
+ case PIX_FMT_0RGB32:
+ s->colorspace= 1;
+ break;
+ default:
+ av_log(avctx, AV_LOG_ERROR, "format not supported\n");
+ return -1;
+ }
+ if (s->transparency) {
+ av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
+ }
+ if (avctx->context_model > 1U) {
+ av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
+ return AVERROR(EINVAL);
+ }
+
for(i=0; i<256; i++){
s->quant_table_count=2;
- if(avctx->bits_per_raw_sample <=8){
+ if(s->bits_per_raw_sample <=8){
s->quant_tables[0][0][i]= quant11[i];
s->quant_tables[0][1][i]= 11*quant11[i];
s->quant_tables[0][2][i]= 11*11*quant11[i];
return AVERROR(ENOMEM);
avctx->coded_frame= &s->picture;
- switch(avctx->pix_fmt){
- case PIX_FMT_YUV444P16:
- case PIX_FMT_YUV422P16:
- case PIX_FMT_YUV420P16:
- if(avctx->bits_per_raw_sample <=8){
- av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
- return -1;
- }
- if(!s->ac){
- av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
- return -1;
- }
- s->version= FFMAX(s->version, 1);
- case PIX_FMT_YUV444P:
- case PIX_FMT_YUV422P:
- case PIX_FMT_YUV420P:
- case PIX_FMT_YUV411P:
- case PIX_FMT_YUV410P:
- s->colorspace= 0;
- break;
- case PIX_FMT_RGB32:
- s->colorspace= 1;
- break;
- default:
- av_log(avctx, AV_LOG_ERROR, "format not supported\n");
- return -1;
- }
+ if(!s->transparency)
+ s->plane_count= 2;
avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
s->picture_number=0;
}else
memset(p->state, 128, CONTEXT_SIZE*p->context_count);
}else{
- for(j=0; j<p->context_count; j++){
+
for(j=0; j<p->context_count; j++){
p->vlc_state[j].drift= 0;
p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
p->vlc_state[j].bias= 0;
p->vlc_state[j].count= 1;
- }
+ }
}
}
}
int x= fs->slice_x;
int y= fs->slice_y;
AVFrame * const p= &f->picture;
+ const int ps= (f->bits_per_raw_sample>8)+1;
if(f->colorspace==0){
const int chroma_width = -((-width )>>f->chroma_h_shift);
const int cx= x>>f->chroma_h_shift;
const int cy= y>>f->chroma_v_shift;
- encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
+ encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
- encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
- encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
+ if (f->chroma_planes){
+ encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
+ encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
+ }
+ if (fs->transparency)
+ encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
}else{
- encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
+ encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
}
emms_c();
uint8_t *buf_p;
int i, ret;
- if (!pkt->data &&
- (ret = av_new_packet(pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
- + FF_MIN_BUFFER_SIZE)) < 0) {
- av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
+ if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
+ + FF_MIN_BUFFER_SIZE)) < 0)
return ret;
- }
ff_init_range_encoder(c, pkt->data, pkt->size);
ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
}
}else{
decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
- for(x=0; x<w; x++){
- ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
+ if(s->packed_at_lsb){
+ for(x=0; x<w; x++){
+ ((uint16_t*)(src + stride*y))[x]= sample[1][x];
+ }
+ }else{
+ for(x=0; x<w; x++){
+ ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
+ }
}
}
//STOP_TIMER("decode-line")}
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
int x, y, p;
- int16_t *sample[3][2];
- for(x=0; x<3; x++){
+ int16_t *sample[4][2];
+ for(x=0; x<4; x++){
sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
}
s->run_index=0;
- memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
+ memset(s->sample_buffer, 0, 8*(w+6)*sizeof(*s->sample_buffer));
for(y=0; y<h; y++){
- for(p=0; p<3; p++){
+ for(p=0; p<3 + s->transparency; p++){
int16_t *temp = sample[p][0]; //FIXME try a normal buffer
sample[p][0]= sample[p][1];
sample[p][1][-1]= sample[p][0][0 ];
sample[p][0][ w]= sample[p][0][w-1];
- decode_line(s, w, sample[p], FFMIN(p, 1), 9);
+ decode_line(s, w, sample[p], (p+1)/2, 9);
}
for(x=0; x<w; x++){
int g= sample[0][1][x];
int b= sample[1][1][x];
int r= sample[2][1][x];
+ int a= sample[3][1][x];
// assert(g>=0 && b>=0 && r>=0);
// assert(g<256 && b<512 && r<512);
b += g;
r += g;
- src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
+ src[x + stride*y]= b + (g<<8) + (r<<16) + (a<<24);
}
}
}
int height= fs->slice_height;
int x= fs->slice_x;
int y= fs->slice_y;
+ const int ps= (c->bits_per_raw_sample>8)+1;
AVFrame * const p= &f->picture;
av_assert1(width && height);
const int chroma_height= -((-height)>>f->chroma_v_shift);
const int cx= x>>f->chroma_h_shift;
const int cy= y>>f->chroma_v_shift;
- decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
+ decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);
- decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
- decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
+ if (f->chroma_planes){
+ decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
+ decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
+ }
+ if (fs->transparency)
+ decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);
}else{
- decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
+ decode_rgb_frame(fs, (uint32_t*)p->data[0] + ps*x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
}
emms_c();
get_rac(c, state); //no chroma = false
f->chroma_h_shift= get_symbol(c, state, 0);
f->chroma_v_shift= get_symbol(c, state, 0);
- get_rac(c, state); //transparency plane
- f->plane_count= 2;
+ f->transparency= get_rac(c, state);
+ f->plane_count= 2 + f->transparency;
f->num_h_slices= 1 + get_symbol(c, state, 0);
f->num_v_slices= 1 + get_symbol(c, state, 0);
if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
f->colorspace= get_symbol(c, state, 0); //YUV cs type
if(f->version>0)
f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
- get_rac(c, state); //no chroma = false
+ f->chroma_planes= get_rac(c, state);
f->chroma_h_shift= get_symbol(c, state, 0);
f->chroma_v_shift= get_symbol(c, state, 0);
- get_rac(c, state); //transparency plane
- f->plane_count= 2;
+ f->transparency= get_rac(c, state);
+ f->plane_count= 2 + f->transparency;
}
if(f->colorspace==0){
- if(f->avctx->bits_per_raw_sample<=8){
+ if(!f->transparency && !f->chroma_planes){
+ if (f->avctx->bits_per_raw_sample<=8)
+ f->avctx->pix_fmt= PIX_FMT_GRAY8;
+ else
+ f->avctx->pix_fmt= PIX_FMT_GRAY16;
+ }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_YUV444P; break;
+ case 0x01: f->avctx->pix_fmt= PIX_FMT_YUV440P; break;
case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
return -1;
}
- }else{
+ }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 0x11: f->avctx->pix_fmt= PIX_FMT_YUVA420P; break;
+ default:
+ av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
+ return -1;
+ }
+ }else if(f->avctx->bits_per_raw_sample==9) {
+ f->packed_at_lsb=1;
+ switch(16*f->chroma_h_shift + f->chroma_v_shift){
+ case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P9; break;
+ case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P9; break;
+ case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P9; break;
+ default:
+ av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
+ return -1;
+ }
+ }else if(f->avctx->bits_per_raw_sample==10) {
+ f->packed_at_lsb=1;
+ switch(16*f->chroma_h_shift + f->chroma_v_shift){
+ case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P10; break;
+ case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P10; break;
+ case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P10; break;
+ default:
+ av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
+ return -1;
+ }
+ }else {
switch(16*f->chroma_h_shift + f->chroma_v_shift){
case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
return -1;
}
- f->avctx->pix_fmt= PIX_FMT_RGB32;
+ if(f->transparency) f->avctx->pix_fmt= PIX_FMT_RGB32;
+ else f->avctx->pix_fmt= PIX_FMT_0RGB32;
}else{
av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
return -1;
for(j=0; j<f->slice_count; j++){
FFV1Context *fs= f->slice_context[j];
fs->ac= f->ac;
+ fs->packed_at_lsb= f->packed_at_lsb;
if(f->version >= 2){
fs->slice_x = get_symbol(c, state, 0) *f->width ;
.encode2 = encode_frame,
.close = common_end,
.capabilities = CODEC_CAP_SLICE_THREADS,
- .pix_fmts = (const enum PixelFormat[]){
- PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P,
- PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16,
- PIX_FMT_YUV444P16, PIX_FMT_NONE
- },
+ .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"),
};
#endif
projects / ffmpeg / blobdiff