xenia-project/FFmpeg
1
0
Fork 0
mirror of https://github.com/xenia-project/FFmpeg.git synced 2024-11-24 12:09:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

unfinished jpeg-ls codec (feel free to finish it ...)

Browse Source 
Originally committed as revision 4752 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Michael Niedermayer 2005-12-18 13:17:44 +00:00
parent a42bed52ca
commit 5639729bed
4 changed files with 457 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
libavcodec/allcodecs.c
View File

@ -131,6 +131,9 @@ void avcodec_register_all(void)
#ifdef CONFIG_LJPEG_ENCODER
register_avcodec(&ljpeg_encoder);
#endif //CONFIG_LJPEG_ENCODER
#ifdef CONFIG_JPEGLS_ENCODER
register_avcodec(&jpegls_encoder);
#endif //CONFIG_JPEGLS_ENCODER
#ifdef CONFIG_ZLIB
#ifdef CONFIG_PNG_ENCODER
register_avcodec(&png_encoder);

10
libavcodec/avcodec.h
View File

@ -44,6 +44,7 @@ enum CodecID {
CODEC_ID_MJPEGB,
CODEC_ID_LJPEG,
CODEC_ID_SP5X,
CODEC_ID_JPEGLS,
CODEC_ID_MPEG4,
CODEC_ID_RAWVIDEO,
CODEC_ID_MSMPEG4V1,
@ -1532,6 +1533,14 @@ typedef struct AVCodecContext {
* - decoding: unused
*/
int context_model;
#if 0
/**
*
* - encoding: unused
* - decoding: set by user.
*/
uint8_t * (*realloc)(struct AVCodecContext *s, uint8_t *buf, int buf_size);
#endif
/**
* slice flags
@ -1944,6 +1953,7 @@ extern AVCodec rv20_encoder;
extern AVCodec dvvideo_encoder;
extern AVCodec mjpeg_encoder;
extern AVCodec ljpeg_encoder;
extern AVCodec jpegls_encoder;
extern AVCodec png_encoder;
extern AVCodec ppm_encoder;
extern AVCodec pgm_encoder;

391
libavcodec/jpeg_ls.c Normal file
View File

@ -0,0 +1,391 @@
/*
* JPEG-LS encoder and decoder
* Copyright (c) 2003 Michael Niedermayer
*
* This library 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.
*
* This library 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
*/
/**
* @file jpeg_ls.c
* JPEG-LS encoder and decoder.
*/
#undef printf
#undef fprintf
static inline int quantize(MJpegDecodeContext *s, int v){ //FIXME optimize
if(v==0) return 0;
if(v < 0){
if (v >-s->t1) return -1;
else if(v >-s->t2) return -2;
else if(v >-s->t3) return -3;
else return -4;
}else{
if (v < s->t1) return 1;
else if(v < s->t2) return 2;
else if(v < s->t3) return 3;
else return 4;
}
}
static inline int predict8(uint8_t *src, uint8_t *last){ //FIXME perhaps its better to suppress these 2
const int LT= last[-1];
const int T= last[ 0];
const int L = src[-1];
return mid_pred(L, L + T - LT, T);
}
static inline int predict16(uint16_t *src, uint16_t *last){
const int LT= last[-1];
const int T= last[ 0];
const int L = src[-1];
return mid_pred(L, L + T - LT, T);
}
static int encode_picture_ls(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
return 0;
}
static int iso_clip(int v, int vmin, int vmax){
if(v > vmax || v < vmin) return vmin;
else return v;
}
static void reset_ls_coding_parameters(MJpegDecodeContext *s, int reset_all){
const int basic_t1= 3;
const int basic_t2= 7;
const int basic_t3= 21;
int factor;
if(s->maxval==0 || reset_all) s->maxval= (1<<s->bits) - 1;
if(s->maxval >=128){
factor= (FFMIN(s->maxval, 4096) + 128)>>8;
if(s->t1==0 || reset_all)
s->t1= iso_clip(factor*(basic_t1-2) + 2 + 3*s->near, s->near+1, s->maxval);
if(s->t2==0 || reset_all)
s->t2= iso_clip(factor*(basic_t2-3) + 3 + 5*s->near, s->t1, s->maxval);
if(s->t3==0 || reset_all)
s->t3= iso_clip(factor*(basic_t3-4) + 4 + 7*s->near, s->t2, s->maxval);
}else{
factor= 256 / (s->maxval + 1);
if(s->t1==0 || reset_all)
s->t1= iso_clip(FFMAX(2, basic_t1/factor + 3*s->near), s->near+1, s->maxval);
if(s->t2==0 || reset_all)
s->t2= iso_clip(FFMAX(3, basic_t2/factor + 5*s->near), s->t1, s->maxval);
if(s->t3==0 || reset_all)
s->t3= iso_clip(FFMAX(4, basic_t3/factor + 6*s->near), s->t2, s->maxval);
}
if(s->reset==0 || reset_all) s->reset= 64;
}
static int decode_lse(MJpegDecodeContext *s)
{
int len, id;
/* XXX: verify len field validity */
len = get_bits(&s->gb, 16);
id = get_bits(&s->gb, 8);
switch(id){
case 1:
s->maxval= get_bits(&s->gb, 16);
s->t1= get_bits(&s->gb, 16);
s->t2= get_bits(&s->gb, 16);
s->t3= get_bits(&s->gb, 16);
s->reset= get_bits(&s->gb, 16);
reset_ls_coding_parameters(s, 0);
//FIXME quant table?
break;
case 2:
case 3:
printf("palette not supported\n");
return -1;
case 4:
printf("oversize image not supported\n");
return -1;
default:
printf("invalid id %d\n", id);
return -1;
}
return 0;
}
#if 0
static inline void update_vlc_state(VlcState * const state, const int v, int half_count){
int drift= state->drift;
int count= state->count;
state->error_sum += ABS(v);
drift += v;
if(count == half_count){
count >>= 1;
drift >>= 1;
state->error_sum >>= 1;
}
count++;
if(drift <= -count){
if(state->bias > -128) state->bias--;
drift += count;
if(drift <= -count)
drift= -count + 1;
}else if(drift > 0){
if(state->bias < 127) state->bias++;
drift -= count;
if(drift > 0)
drift= 0;
}
state->drift= drift;
state->count= count;
}
#define R(p, i) (is_uint8 ? (((uint8_t*)p)[i] : ((uint16_t*)p)[i])
static inline int ls_decode_line(MJpegDecodeContext *s, void *lastv, void *dstv, int last2,
int w, int point_transform, int is_uint8){
int i, x, y;
for(x=0; x < w; x++){
int l, t, lt, rt;
t= R(last, 0);
if(x){
l = t;
lt= last2;
}else{
l = R(dst, x-1);
lt= R(last, x-1);
}
if(x<w-1) rt= R(last, x+1);
else rt= t;
hr_gradient= rt - t;
hl_gradient= t - lt;
v_gradient= lt - l;
context= quantize(s, v_gradient) + 9*(quantize(s, hl_gradient) + 9*quantize(s, hr_gradient));
if(context){
int pred= mid_pred(l, l + t - lt, t);
if(context < 0){
context= -context;
sign= 1;
pred= clip(0, pred - state->bias, maxval);
}else{
sign= 0;
pred= clip(0, pred + state->bias, maxval);
}
i= state->count;
k=0;
while(i < state->error_sum){ //FIXME optimize
k++;
i += i;
}
v= get_ur_golomb_jpegls(gb, k, LIMIT-qbpp, qbpp);
#if 1
v++;
if(v&1) v= (v>>1);
else v= -(v>>1);
if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
#else
v ^= (k==0 && 2*state->drift <= - state->count);
v++;
if(v&1) v= (v>>1);
else v= -(v>>1);
#endif
update_vlc_state(state, v, half_count);
if(sign) v= -v;
if(is_uint8) ((uint8_t *)dst)[x]= (pred + v) & maxval;
else ((uint16_t*)dst)[x]= (pred + v) & maxval;
}else{
int run_count;
while(get_bits1(&s->gb)){
run_count = 1<<log2_run[run_index];
if(x + run_count > w) run_count= w - x;
else run_index++;
for(; run_count; run_count--){
if(is_uint8) ((uint8_t *)dst)[x++]= l;
else ((uint16_t*)dst)[x++]= l;
}
if(x >= w) return 0;
}
run_count= get_bits(&s->gb, log2_run[run_index]);
for(; run_count; run_count--){
if(is_uint8) ((uint8_t *)dst)[x++]= l;
else ((uint16_t*)dst)[x++]= l;
}
if(run_index) run_index--;
if(x >= w) return 0;
t= R(last, 0);
RItype= (l==t);
if(l==t){
state= 366;
temp= state->error_sum + (state->count>>1);
}else{
state= 365;
temp= state->error_sum;
}
pred= t;
sign= l > t;
i= state->count;
k=0;
while(i < temp){ //FIXME optimize
k++;
i += i;
}
assert(Errval != 0);
map = (k==0 && 2*Nn < state->count) == (Errval>0);
if(run_count==0 && run_mode==1){
if(get_bits1(&s->gb)){
run_count = 1<<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]);
else run_count=0;
if(run_index) run_index--;
run_mode=2;
}
}
run_count--;
if(run_count < 0){
run_mode=0;
run_count=0;
diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
if(diff>=0) diff++;
}else
diff=0;
}
}
/* if (s->restart_interval && !s->restart_count)
s->restart_count = s->restart_interval;*/
if(mb_x==0 || mb_y==0 || s->interlaced){
for(i=0;i<nb_components;i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j, linesize;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
linesize= s->linesize[c];
for(j=0; j<n; j++) {
int pred;
ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
if(y==0 && mb_y==0){
if(x==0 && mb_x==0){
pred= 128 << point_transform;
}else{
pred= ptr[-1];
}
}else{
if(x==0 && mb_x==0){
pred= ptr[-linesize];
}else{
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
}
}
if (s->interlaced && s->bottom_field)
ptr += linesize >> 1;
*ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
if (++x == h) {
x = 0;
y++;
}
}
}
}else{
for(i=0;i<nb_components;i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j, linesize;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
linesize= s->linesize[c];
for(j=0; j<n; j++) {
int pred;
ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
*ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
if (++x == h) {
x = 0;
y++;
}
}
}
}
if (s->restart_interval && !--s->restart_count) {
align_get_bits(&s->gb);
skip_bits(&s->gb, 16); /* skip RSTn */
}
return 0;
}
#endif
#ifdef CONFIG_ENCODERS
AVCodec jpegls_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
"jpegls",
CODEC_TYPE_VIDEO,
CODEC_ID_JPEGLS,
sizeof(MpegEncContext),
MPV_encode_init,
encode_picture_ls,
MPV_encode_end,
};
#endif

62
libavcodec/mjpeg.c
View File

@ -118,8 +118,8 @@ typedef enum {
JPG4 = 0xf4,
JPG5 = 0xf5,
JPG6 = 0xf6,
JPG7 = 0xf7,
JPG8 = 0xf8,
SOF48 = 0xf7, ///< JPEG-LS
LSE = 0xf8, ///< JPEG-LS extension parameters
JPG9 = 0xf9,
JPG10 = 0xfa,
JPG11 = 0xfb,
@ -417,7 +417,10 @@ static void jpeg_put_comments(MpegEncContext *s)
void mjpeg_picture_header(MpegEncContext *s)
{
const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
const int ls = s->avctx->codec_id == CODEC_ID_JPEGLS;
assert(!(ls && s->mjpeg_write_tables));
put_marker(&s->pb, SOI);
@ -427,7 +430,12 @@ void mjpeg_picture_header(MpegEncContext *s)
if (s->mjpeg_write_tables) jpeg_table_header(s);
put_marker(&s->pb, lossless ? SOF3 : SOF0);
switch(s->avctx->codec_id){
case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
default: assert(0);
}
put_bits(&s->pb, 16, 17);
if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
@ -485,9 +493,18 @@ void mjpeg_picture_header(MpegEncContext *s)
put_bits(&s->pb, 4, 1); /* DC huffman table index */
put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
switch(s->avctx->codec_id){
case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
case CODEC_ID_JPEGLS: put_bits(&s->pb, 8, 1); break; /* ILV = line interleaved */
default: assert(0);
}
put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
//FIXME DC/AC entropy table selectors stuff in jpegls
}
static void escape_FF(MpegEncContext *s, int start)
@ -827,11 +844,17 @@ typedef struct MJpegDecodeContext {
int interlaced; /* true if interlaced */
int bottom_field; /* true if bottom field */
int lossless;
int ls;
int rgb;
int rct; /* standard rct */
int pegasus_rct; /* pegasus reversible colorspace transform */
int bits; /* bits per component */
int maxval;
int near; ///< near lossless bound (si 0 for lossless)
int t1,t2,t3;
int reset; ///< context halfing intervall ?rename
int width, height;
int mb_width, mb_height;
int nb_components;
@ -864,6 +887,8 @@ typedef struct MJpegDecodeContext {
int mjpb_skiptosod;
} MJpegDecodeContext;
#include "jpeg_ls.c" //FIXME make jpeg-ls more independant
static int mjpeg_decode_dht(MJpegDecodeContext *s);
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
@ -1521,8 +1546,8 @@ static int mjpeg_decode_sos(MJpegDecodeContext *s)
#endif
}
predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
skip_bits(&s->gb, 8); /* Se */
predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
int ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
skip_bits(&s->gb, 4); /* Ah */
point_transform= get_bits(&s->gb, 4); /* Al */
@ -1544,13 +1569,19 @@ static int mjpeg_decode_sos(MJpegDecodeContext *s)
}
if(s->avctx->debug & FF_DEBUG_PICT_INFO)
av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "",
predictor, point_transform, ilv, s->bits,
s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
/* mjpeg-b can have padding bytes between sos and image data, skip them */
for (i = s->mjpb_skiptosod; i > 0; i--)
skip_bits(&s->gb, 8);
if(s->lossless){
if(s->ls){
// for(){
}else{
if(s->rgb){
if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
return -1;
@ -1558,6 +1589,7 @@ static int mjpeg_decode_sos(MJpegDecodeContext *s)
if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
return -1;
}
}
}else{
if(mjpeg_decode_scan(s) < 0)
return -1;
@ -1894,6 +1926,8 @@ static int mjpeg_decode_frame(AVCodecContext *avctx,
switch(start_code) {
case SOI:
s->restart_interval = 0;
reset_ls_coding_parameters(s, 1);
s->restart_count = 0;
/* nothing to do on SOI */
break;
@ -1916,6 +1950,16 @@ static int mjpeg_decode_frame(AVCodecContext *avctx,
if (mjpeg_decode_sof(s) < 0)
return -1;
break;
case SOF48:
s->lossless=1;
s->ls=1;
if (mjpeg_decode_sof(s) < 0)
return -1;
break;
case LSE:
if (decode_lse(s) < 0)
return -1;
break;
case EOI:
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
break;