00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00031 #include "avcodec.h"
00032 #include "bitstream.h"
00033 #include "dsputil.h"
00034
00035 #define VLC_BITS 11
00036
00037 #ifdef WORDS_BIGENDIAN
00038 #define B 3
00039 #define G 2
00040 #define R 1
00041 #else
00042 #define B 0
00043 #define G 1
00044 #define R 2
00045 #endif
00046
00047 typedef enum Predictor{
00048 LEFT= 0,
00049 PLANE,
00050 MEDIAN,
00051 } Predictor;
00052
00053 typedef struct HYuvContext{
00054 AVCodecContext *avctx;
00055 Predictor predictor;
00056 GetBitContext gb;
00057 PutBitContext pb;
00058 int interlaced;
00059 int decorrelate;
00060 int bitstream_bpp;
00061 int version;
00062 int yuy2;
00063 int bgr32;
00064 int width, height;
00065 int flags;
00066 int context;
00067 int picture_number;
00068 int last_slice_end;
00069 uint8_t *temp[3];
00070 uint64_t stats[3][256];
00071 uint8_t len[3][256];
00072 uint32_t bits[3][256];
00073 uint32_t pix_bgr_map[1<<VLC_BITS];
00074 VLC vlc[6];
00075 AVFrame picture;
00076 uint8_t *bitstream_buffer;
00077 unsigned int bitstream_buffer_size;
00078 DSPContext dsp;
00079 }HYuvContext;
00080
00081 static const unsigned char classic_shift_luma[] = {
00082 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
00083 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
00084 69,68, 0
00085 };
00086
00087 static const unsigned char classic_shift_chroma[] = {
00088 66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
00089 56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
00090 214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
00091 };
00092
00093 static const unsigned char classic_add_luma[256] = {
00094 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
00095 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
00096 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
00097 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
00098 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
00099 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
00100 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
00101 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
00102 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
00103 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
00104 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
00105 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
00106 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
00107 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
00108 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
00109 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
00110 };
00111
00112 static const unsigned char classic_add_chroma[256] = {
00113 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
00114 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
00115 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
00116 43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
00117 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
00118 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
00119 17, 14, 5, 6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
00120 112,113,114,115, 4,117,118, 92, 94,121,122, 3,124,103, 2, 1,
00121 0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
00122 135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
00123 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
00124 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
00125 7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
00126 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
00127 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
00128 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
00129 };
00130
00131 static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
00132 int i;
00133
00134 for(i=0; i<w-1; i++){
00135 acc+= src[i];
00136 dst[i]= acc;
00137 i++;
00138 acc+= src[i];
00139 dst[i]= acc;
00140 }
00141
00142 for(; i<w; i++){
00143 acc+= src[i];
00144 dst[i]= acc;
00145 }
00146
00147 return acc;
00148 }
00149
00150 static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
00151 int i;
00152 uint8_t l, lt;
00153
00154 l= *left;
00155 lt= *left_top;
00156
00157 for(i=0; i<w; i++){
00158 l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
00159 lt= src1[i];
00160 dst[i]= l;
00161 }
00162
00163 *left= l;
00164 *left_top= lt;
00165 }
00166
00167 static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
00168 int i;
00169 int r,g,b;
00170 r= *red;
00171 g= *green;
00172 b= *blue;
00173
00174 for(i=0; i<w; i++){
00175 b+= src[4*i+B];
00176 g+= src[4*i+G];
00177 r+= src[4*i+R];
00178
00179 dst[4*i+B]= b;
00180 dst[4*i+G]= g;
00181 dst[4*i+R]= r;
00182 }
00183
00184 *red= r;
00185 *green= g;
00186 *blue= b;
00187 }
00188
00189 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
00190 int i;
00191 if(w<32){
00192 for(i=0; i<w; i++){
00193 const int temp= src[i];
00194 dst[i]= temp - left;
00195 left= temp;
00196 }
00197 return left;
00198 }else{
00199 for(i=0; i<16; i++){
00200 const int temp= src[i];
00201 dst[i]= temp - left;
00202 left= temp;
00203 }
00204 s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
00205 return src[w-1];
00206 }
00207 }
00208
00209 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
00210 int i;
00211 int r,g,b;
00212 r= *red;
00213 g= *green;
00214 b= *blue;
00215 for(i=0; i<FFMIN(w,4); i++){
00216 const int rt= src[i*4+R];
00217 const int gt= src[i*4+G];
00218 const int bt= src[i*4+B];
00219 dst[i*4+R]= rt - r;
00220 dst[i*4+G]= gt - g;
00221 dst[i*4+B]= bt - b;
00222 r = rt;
00223 g = gt;
00224 b = bt;
00225 }
00226 s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
00227 *red= src[(w-1)*4+R];
00228 *green= src[(w-1)*4+G];
00229 *blue= src[(w-1)*4+B];
00230 }
00231
00232 static void read_len_table(uint8_t *dst, GetBitContext *gb){
00233 int i, val, repeat;
00234
00235 for(i=0; i<256;){
00236 repeat= get_bits(gb, 3);
00237 val = get_bits(gb, 5);
00238 if(repeat==0)
00239 repeat= get_bits(gb, 8);
00240
00241 while (repeat--)
00242 dst[i++] = val;
00243 }
00244 }
00245
00246 static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
00247 int len, index;
00248 uint32_t bits=0;
00249
00250 for(len=32; len>0; len--){
00251 for(index=0; index<256; index++){
00252 if(len_table[index]==len)
00253 dst[index]= bits++;
00254 }
00255 if(bits & 1){
00256 av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
00257 return -1;
00258 }
00259 bits >>= 1;
00260 }
00261 return 0;
00262 }
00263
00264 #ifdef CONFIG_ENCODERS
00265 typedef struct {
00266 uint64_t val;
00267 int name;
00268 } heap_elem_t;
00269
00270 static void heap_sift(heap_elem_t *h, int root, int size)
00271 {
00272 while(root*2+1 < size) {
00273 int child = root*2+1;
00274 if(child < size-1 && h[child].val > h[child+1].val)
00275 child++;
00276 if(h[root].val > h[child].val) {
00277 FFSWAP(heap_elem_t, h[root], h[child]);
00278 root = child;
00279 } else
00280 break;
00281 }
00282 }
00283
00284 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
00285 heap_elem_t h[size];
00286 int up[2*size];
00287 int len[2*size];
00288 int offset, i, next;
00289
00290 for(offset=1; ; offset<<=1){
00291 for(i=0; i<size; i++){
00292 h[i].name = i;
00293 h[i].val = (stats[i] << 8) + offset;
00294 }
00295 for(i=size/2-1; i>=0; i--)
00296 heap_sift(h, i, size);
00297
00298 for(next=size; next<size*2-1; next++){
00299
00300 uint64_t min1v = h[0].val;
00301 up[h[0].name] = next;
00302 h[0].val = INT64_MAX;
00303 heap_sift(h, 0, size);
00304 up[h[0].name] = next;
00305 h[0].name = next;
00306 h[0].val += min1v;
00307 heap_sift(h, 0, size);
00308 }
00309
00310 len[2*size-2] = 0;
00311 for(i=2*size-3; i>=size; i--)
00312 len[i] = len[up[i]] + 1;
00313 for(i=0; i<size; i++) {
00314 dst[i] = len[up[i]] + 1;
00315 if(dst[i] >= 32) break;
00316 }
00317 if(i==size) break;
00318 }
00319 }
00320 #endif
00321
00322 static void generate_joint_tables(HYuvContext *s){
00323 uint16_t symbols[1<<VLC_BITS];
00324 uint16_t bits[1<<VLC_BITS];
00325 uint8_t len[1<<VLC_BITS];
00326 if(s->bitstream_bpp < 24){
00327 int p, i, y, u;
00328 for(p=0; p<3; p++){
00329 for(i=y=0; y<256; y++){
00330 int len0 = s->len[0][y];
00331 int limit = VLC_BITS - len0;
00332 if(limit <= 0)
00333 continue;
00334 for(u=0; u<256; u++){
00335 int len1 = s->len[p][u];
00336 if(len1 > limit)
00337 continue;
00338 len[i] = len0 + len1;
00339 bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
00340 symbols[i] = (y<<8) + u;
00341 if(symbols[i] != 0xffff)
00342 i++;
00343 }
00344 }
00345 free_vlc(&s->vlc[3+p]);
00346 init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
00347 }
00348 }else{
00349 uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
00350 int i, b, g, r, code;
00351 int p0 = s->decorrelate;
00352 int p1 = !s->decorrelate;
00353
00354
00355
00356 for(i=0, g=-16; g<16; g++){
00357 int len0 = s->len[p0][g&255];
00358 int limit0 = VLC_BITS - len0;
00359 if(limit0 < 2)
00360 continue;
00361 for(b=-16; b<16; b++){
00362 int len1 = s->len[p1][b&255];
00363 int limit1 = limit0 - len1;
00364 if(limit1 < 1)
00365 continue;
00366 code = (s->bits[p0][g&255] << len1) + s->bits[p1][b&255];
00367 for(r=-16; r<16; r++){
00368 int len2 = s->len[2][r&255];
00369 if(len2 > limit1)
00370 continue;
00371 len[i] = len0 + len1 + len2;
00372 bits[i] = (code << len2) + s->bits[2][r&255];
00373 if(s->decorrelate){
00374 map[i][G] = g;
00375 map[i][B] = g+b;
00376 map[i][R] = g+r;
00377 }else{
00378 map[i][B] = g;
00379 map[i][G] = b;
00380 map[i][R] = r;
00381 }
00382 i++;
00383 }
00384 }
00385 }
00386 free_vlc(&s->vlc[3]);
00387 init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
00388 }
00389 }
00390
00391 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
00392 GetBitContext gb;
00393 int i;
00394
00395 init_get_bits(&gb, src, length*8);
00396
00397 for(i=0; i<3; i++){
00398 read_len_table(s->len[i], &gb);
00399
00400 if(generate_bits_table(s->bits[i], s->len[i])<0){
00401 return -1;
00402 }
00403 #if 0
00404 for(j=0; j<256; j++){
00405 printf("%6X, %2d, %3d\n", s->bits[i][j], s->len[i][j], j);
00406 }
00407 #endif
00408 free_vlc(&s->vlc[i]);
00409 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
00410 }
00411
00412 generate_joint_tables(s);
00413
00414 return (get_bits_count(&gb)+7)/8;
00415 }
00416
00417 static int read_old_huffman_tables(HYuvContext *s){
00418 #if 1
00419 GetBitContext gb;
00420 int i;
00421
00422 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
00423 read_len_table(s->len[0], &gb);
00424 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
00425 read_len_table(s->len[1], &gb);
00426
00427 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i];
00428 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
00429
00430 if(s->bitstream_bpp >= 24){
00431 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
00432 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
00433 }
00434 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
00435 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
00436
00437 for(i=0; i<3; i++){
00438 free_vlc(&s->vlc[i]);
00439 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
00440 }
00441
00442 generate_joint_tables(s);
00443
00444 return 0;
00445 #else
00446 av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
00447 return -1;
00448 #endif
00449 }
00450
00451 static void alloc_temp(HYuvContext *s){
00452 int i;
00453
00454 if(s->bitstream_bpp<24){
00455 for(i=0; i<3; i++){
00456 s->temp[i]= av_malloc(s->width + 16);
00457 }
00458 }else{
00459 for(i=0; i<2; i++){
00460 s->temp[i]= av_malloc(4*s->width + 16);
00461 }
00462 }
00463 }
00464
00465 static int common_init(AVCodecContext *avctx){
00466 HYuvContext *s = avctx->priv_data;
00467
00468 s->avctx= avctx;
00469 s->flags= avctx->flags;
00470
00471 dsputil_init(&s->dsp, avctx);
00472
00473 s->width= avctx->width;
00474 s->height= avctx->height;
00475 assert(s->width>0 && s->height>0);
00476
00477 return 0;
00478 }
00479
00480 #ifdef CONFIG_DECODERS
00481 static int decode_init(AVCodecContext *avctx)
00482 {
00483 HYuvContext *s = avctx->priv_data;
00484
00485 common_init(avctx);
00486 memset(s->vlc, 0, 3*sizeof(VLC));
00487
00488 avctx->coded_frame= &s->picture;
00489 s->interlaced= s->height > 288;
00490
00491 s->bgr32=1;
00492
00493
00494 if(avctx->extradata_size){
00495 if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
00496 s->version=1;
00497 else
00498 s->version=2;
00499 }else
00500 s->version=0;
00501
00502 if(s->version==2){
00503 int method, interlace;
00504
00505 method= ((uint8_t*)avctx->extradata)[0];
00506 s->decorrelate= method&64 ? 1 : 0;
00507 s->predictor= method&63;
00508 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
00509 if(s->bitstream_bpp==0)
00510 s->bitstream_bpp= avctx->bits_per_sample&~7;
00511 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
00512 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
00513 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
00514
00515 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
00516 return -1;
00517 }else{
00518 switch(avctx->bits_per_sample&7){
00519 case 1:
00520 s->predictor= LEFT;
00521 s->decorrelate= 0;
00522 break;
00523 case 2:
00524 s->predictor= LEFT;
00525 s->decorrelate= 1;
00526 break;
00527 case 3:
00528 s->predictor= PLANE;
00529 s->decorrelate= avctx->bits_per_sample >= 24;
00530 break;
00531 case 4:
00532 s->predictor= MEDIAN;
00533 s->decorrelate= 0;
00534 break;
00535 default:
00536 s->predictor= LEFT;
00537 s->decorrelate= 0;
00538 break;
00539 }
00540 s->bitstream_bpp= avctx->bits_per_sample & ~7;
00541 s->context= 0;
00542
00543 if(read_old_huffman_tables(s) < 0)
00544 return -1;
00545 }
00546
00547 switch(s->bitstream_bpp){
00548 case 12:
00549 avctx->pix_fmt = PIX_FMT_YUV420P;
00550 break;
00551 case 16:
00552 if(s->yuy2){
00553 avctx->pix_fmt = PIX_FMT_YUYV422;
00554 }else{
00555 avctx->pix_fmt = PIX_FMT_YUV422P;
00556 }
00557 break;
00558 case 24:
00559 case 32:
00560 if(s->bgr32){
00561 avctx->pix_fmt = PIX_FMT_RGB32;
00562 }else{
00563 avctx->pix_fmt = PIX_FMT_BGR24;
00564 }
00565 break;
00566 default:
00567 assert(0);
00568 }
00569
00570 alloc_temp(s);
00571
00572
00573
00574 return 0;
00575 }
00576 #endif
00577
00578 #ifdef CONFIG_ENCODERS
00579 static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
00580 int i;
00581 int index= 0;
00582
00583 for(i=0; i<256;){
00584 int val= len[i];
00585 int repeat=0;
00586
00587 for(; i<256 && len[i]==val && repeat<255; i++)
00588 repeat++;
00589
00590 assert(val < 32 && val >0 && repeat<256 && repeat>0);
00591 if(repeat>7){
00592 buf[index++]= val;
00593 buf[index++]= repeat;
00594 }else{
00595 buf[index++]= val | (repeat<<5);
00596 }
00597 }
00598
00599 return index;
00600 }
00601
00602 static int encode_init(AVCodecContext *avctx)
00603 {
00604 HYuvContext *s = avctx->priv_data;
00605 int i, j;
00606
00607 common_init(avctx);
00608
00609 avctx->extradata= av_mallocz(1024*30);
00610 avctx->stats_out= av_mallocz(1024*30);
00611 s->version=2;
00612
00613 avctx->coded_frame= &s->picture;
00614
00615 switch(avctx->pix_fmt){
00616 case PIX_FMT_YUV420P:
00617 s->bitstream_bpp= 12;
00618 break;
00619 case PIX_FMT_YUV422P:
00620 s->bitstream_bpp= 16;
00621 break;
00622 case PIX_FMT_RGB32:
00623 s->bitstream_bpp= 24;
00624 break;
00625 default:
00626 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
00627 return -1;
00628 }
00629 avctx->bits_per_sample= s->bitstream_bpp;
00630 s->decorrelate= s->bitstream_bpp >= 24;
00631 s->predictor= avctx->prediction_method;
00632 s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
00633 if(avctx->context_model==1){
00634 s->context= avctx->context_model;
00635 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
00636 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
00637 return -1;
00638 }
00639 }else s->context= 0;
00640
00641 if(avctx->codec->id==CODEC_ID_HUFFYUV){
00642 if(avctx->pix_fmt==PIX_FMT_YUV420P){
00643 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
00644 return -1;
00645 }
00646 if(avctx->context_model){
00647 av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
00648 return -1;
00649 }
00650 if(s->interlaced != ( s->height > 288 ))
00651 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
00652 }
00653
00654 if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
00655 av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
00656 return -1;
00657 }
00658
00659 ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
00660 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
00661 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
00662 if(s->context)
00663 ((uint8_t*)avctx->extradata)[2]|= 0x40;
00664 ((uint8_t*)avctx->extradata)[3]= 0;
00665 s->avctx->extradata_size= 4;
00666
00667 if(avctx->stats_in){
00668 char *p= avctx->stats_in;
00669
00670 for(i=0; i<3; i++)
00671 for(j=0; j<256; j++)
00672 s->stats[i][j]= 1;
00673
00674 for(;;){
00675 for(i=0; i<3; i++){
00676 char *next;
00677
00678 for(j=0; j<256; j++){
00679 s->stats[i][j]+= strtol(p, &next, 0);
00680 if(next==p) return -1;
00681 p=next;
00682 }
00683 }
00684 if(p[0]==0 || p[1]==0 || p[2]==0) break;
00685 }
00686 }else{
00687 for(i=0; i<3; i++)
00688 for(j=0; j<256; j++){
00689 int d= FFMIN(j, 256-j);
00690
00691 s->stats[i][j]= 100000000/(d+1);
00692 }
00693 }
00694
00695 for(i=0; i<3; i++){
00696 generate_len_table(s->len[i], s->stats[i], 256);
00697
00698 if(generate_bits_table(s->bits[i], s->len[i])<0){
00699 return -1;
00700 }
00701
00702 s->avctx->extradata_size+=
00703 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
00704 }
00705
00706 if(s->context){
00707 for(i=0; i<3; i++){
00708 int pels = s->width*s->height / (i?40:10);
00709 for(j=0; j<256; j++){
00710 int d= FFMIN(j, 256-j);
00711 s->stats[i][j]= pels/(d+1);
00712 }
00713 }
00714 }else{
00715 for(i=0; i<3; i++)
00716 for(j=0; j<256; j++)
00717 s->stats[i][j]= 0;
00718 }
00719
00720
00721
00722 alloc_temp(s);
00723
00724 s->picture_number=0;
00725
00726 return 0;
00727 }
00728 #endif
00729
00730
00731
00732 #define READ_2PIX(dst0, dst1, plane1){\
00733 uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
00734 if(code != 0xffff){\
00735 dst0 = code>>8;\
00736 dst1 = code;\
00737 }else{\
00738 dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
00739 dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
00740 }\
00741 }
00742
00743 static void decode_422_bitstream(HYuvContext *s, int count){
00744 int i;
00745
00746 count/=2;
00747
00748 for(i=0; i<count; i++){
00749 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
00750 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
00751 }
00752 }
00753
00754 static void decode_gray_bitstream(HYuvContext *s, int count){
00755 int i;
00756
00757 count/=2;
00758
00759 for(i=0; i<count; i++){
00760 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
00761 }
00762 }
00763
00764 #ifdef CONFIG_ENCODERS
00765 static int encode_422_bitstream(HYuvContext *s, int count){
00766 int i;
00767
00768 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
00769 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00770 return -1;
00771 }
00772
00773 #define LOAD4\
00774 int y0 = s->temp[0][2*i];\
00775 int y1 = s->temp[0][2*i+1];\
00776 int u0 = s->temp[1][i];\
00777 int v0 = s->temp[2][i];
00778
00779 count/=2;
00780 if(s->flags&CODEC_FLAG_PASS1){
00781 for(i=0; i<count; i++){
00782 LOAD4;
00783 s->stats[0][y0]++;
00784 s->stats[1][u0]++;
00785 s->stats[0][y1]++;
00786 s->stats[2][v0]++;
00787 }
00788 }
00789 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
00790 return 0;
00791 if(s->context){
00792 for(i=0; i<count; i++){
00793 LOAD4;
00794 s->stats[0][y0]++;
00795 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
00796 s->stats[1][u0]++;
00797 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
00798 s->stats[0][y1]++;
00799 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00800 s->stats[2][v0]++;
00801 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
00802 }
00803 }else{
00804 for(i=0; i<count; i++){
00805 LOAD4;
00806 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
00807 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
00808 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00809 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
00810 }
00811 }
00812 return 0;
00813 }
00814
00815 static int encode_gray_bitstream(HYuvContext *s, int count){
00816 int i;
00817
00818 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
00819 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00820 return -1;
00821 }
00822
00823 #define LOAD2\
00824 int y0 = s->temp[0][2*i];\
00825 int y1 = s->temp[0][2*i+1];
00826 #define STAT2\
00827 s->stats[0][y0]++;\
00828 s->stats[0][y1]++;
00829 #define WRITE2\
00830 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
00831 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00832
00833 count/=2;
00834 if(s->flags&CODEC_FLAG_PASS1){
00835 for(i=0; i<count; i++){
00836 LOAD2;
00837 STAT2;
00838 }
00839 }
00840 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
00841 return 0;
00842
00843 if(s->context){
00844 for(i=0; i<count; i++){
00845 LOAD2;
00846 STAT2;
00847 WRITE2;
00848 }
00849 }else{
00850 for(i=0; i<count; i++){
00851 LOAD2;
00852 WRITE2;
00853 }
00854 }
00855 return 0;
00856 }
00857 #endif
00858
00859 static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
00860 int i;
00861 for(i=0; i<count; i++){
00862 int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
00863 if(code != -1){
00864 *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
00865 }else if(decorrelate){
00866 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
00867 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
00868 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
00869 }else{
00870 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
00871 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
00872 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
00873 }
00874 if(alpha)
00875 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
00876 }
00877 }
00878
00879 static void decode_bgr_bitstream(HYuvContext *s, int count){
00880 if(s->decorrelate){
00881 if(s->bitstream_bpp==24)
00882 decode_bgr_1(s, count, 1, 0);
00883 else
00884 decode_bgr_1(s, count, 1, 1);
00885 }else{
00886 if(s->bitstream_bpp==24)
00887 decode_bgr_1(s, count, 0, 0);
00888 else
00889 decode_bgr_1(s, count, 0, 1);
00890 }
00891 }
00892
00893 static int encode_bgr_bitstream(HYuvContext *s, int count){
00894 int i;
00895
00896 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
00897 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00898 return -1;
00899 }
00900
00901 #define LOAD3\
00902 int g= s->temp[0][4*i+G];\
00903 int b= (s->temp[0][4*i+B] - g) & 0xff;\
00904 int r= (s->temp[0][4*i+R] - g) & 0xff;
00905 #define STAT3\
00906 s->stats[0][b]++;\
00907 s->stats[1][g]++;\
00908 s->stats[2][r]++;
00909 #define WRITE3\
00910 put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
00911 put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
00912 put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
00913
00914 if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
00915 for(i=0; i<count; i++){
00916 LOAD3;
00917 STAT3;
00918 }
00919 }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
00920 for(i=0; i<count; i++){
00921 LOAD3;
00922 STAT3;
00923 WRITE3;
00924 }
00925 }else{
00926 for(i=0; i<count; i++){
00927 LOAD3;
00928 WRITE3;
00929 }
00930 }
00931 return 0;
00932 }
00933
00934 #ifdef CONFIG_DECODERS
00935 static void draw_slice(HYuvContext *s, int y){
00936 int h, cy;
00937 int offset[4];
00938
00939 if(s->avctx->draw_horiz_band==NULL)
00940 return;
00941
00942 h= y - s->last_slice_end;
00943 y -= h;
00944
00945 if(s->bitstream_bpp==12){
00946 cy= y>>1;
00947 }else{
00948 cy= y;
00949 }
00950
00951 offset[0] = s->picture.linesize[0]*y;
00952 offset[1] = s->picture.linesize[1]*cy;
00953 offset[2] = s->picture.linesize[2]*cy;
00954 offset[3] = 0;
00955 emms_c();
00956
00957 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
00958
00959 s->last_slice_end= y + h;
00960 }
00961
00962 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){
00963 HYuvContext *s = avctx->priv_data;
00964 const int width= s->width;
00965 const int width2= s->width>>1;
00966 const int height= s->height;
00967 int fake_ystride, fake_ustride, fake_vstride;
00968 AVFrame * const p= &s->picture;
00969 int table_size= 0;
00970
00971 AVFrame *picture = data;
00972
00973 s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
00974
00975 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
00976
00977 if(p->data[0])
00978 avctx->release_buffer(avctx, p);
00979
00980 p->reference= 0;
00981 if(avctx->get_buffer(avctx, p) < 0){
00982 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00983 return -1;
00984 }
00985
00986 if(s->context){
00987 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
00988 if(table_size < 0)
00989 return -1;
00990 }
00991
00992 if((unsigned)(buf_size-table_size) >= INT_MAX/8)
00993 return -1;
00994
00995 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
00996
00997 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0];
00998 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1];
00999 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2];
01000
01001 s->last_slice_end= 0;
01002
01003 if(s->bitstream_bpp<24){
01004 int y, cy;
01005 int lefty, leftu, leftv;
01006 int lefttopy, lefttopu, lefttopv;
01007
01008 if(s->yuy2){
01009 p->data[0][3]= get_bits(&s->gb, 8);
01010 p->data[0][2]= get_bits(&s->gb, 8);
01011 p->data[0][1]= get_bits(&s->gb, 8);
01012 p->data[0][0]= get_bits(&s->gb, 8);
01013
01014 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
01015 return -1;
01016 }else{
01017
01018 leftv= p->data[2][0]= get_bits(&s->gb, 8);
01019 lefty= p->data[0][1]= get_bits(&s->gb, 8);
01020 leftu= p->data[1][0]= get_bits(&s->gb, 8);
01021 p->data[0][0]= get_bits(&s->gb, 8);
01022
01023 switch(s->predictor){
01024 case LEFT:
01025 case PLANE:
01026 decode_422_bitstream(s, width-2);
01027 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
01028 if(!(s->flags&CODEC_FLAG_GRAY)){
01029 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
01030 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
01031 }
01032
01033 for(cy=y=1; y<s->height; y++,cy++){
01034 uint8_t *ydst, *udst, *vdst;
01035
01036 if(s->bitstream_bpp==12){
01037 decode_gray_bitstream(s, width);
01038
01039 ydst= p->data[0] + p->linesize[0]*y;
01040
01041 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
01042 if(s->predictor == PLANE){
01043 if(y>s->interlaced)
01044 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
01045 }
01046 y++;
01047 if(y>=s->height) break;
01048 }
01049
01050 draw_slice(s, y);
01051
01052 ydst= p->data[0] + p->linesize[0]*y;
01053 udst= p->data[1] + p->linesize[1]*cy;
01054 vdst= p->data[2] + p->linesize[2]*cy;
01055
01056 decode_422_bitstream(s, width);
01057 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
01058 if(!(s->flags&CODEC_FLAG_GRAY)){
01059 leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
01060 leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
01061 }
01062 if(s->predictor == PLANE){
01063 if(cy>s->interlaced){
01064 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
01065 if(!(s->flags&CODEC_FLAG_GRAY)){
01066 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
01067 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
01068 }
01069 }
01070 }
01071 }
01072 draw_slice(s, height);
01073
01074 break;
01075 case MEDIAN:
01076
01077 decode_422_bitstream(s, width-2);
01078 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
01079 if(!(s->flags&CODEC_FLAG_GRAY)){
01080 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
01081 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
01082 }
01083
01084 cy=y=1;
01085
01086
01087 if(s->interlaced){
01088 decode_422_bitstream(s, width);
01089 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
01090 if(!(s->flags&CODEC_FLAG_GRAY)){
01091 leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
01092 leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
01093 }
01094 y++; cy++;
01095 }
01096
01097
01098 decode_422_bitstream(s, 4);
01099 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
01100 if(!(s->flags&CODEC_FLAG_GRAY)){
01101 leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
01102 leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
01103 }
01104
01105
01106 lefttopy= p->data[0][3];
01107 decode_422_bitstream(s, width-4);
01108 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
01109 if(!(s->flags&CODEC_FLAG_GRAY)){
01110 lefttopu= p->data[1][1];
01111 lefttopv= p->data[2][1];
01112 add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
01113 add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
01114 }
01115 y++; cy++;
01116
01117 for(; y<height; y++,cy++){
01118 uint8_t *ydst, *udst, *vdst;
01119
01120 if(s->bitstream_bpp==12){
01121 while(2*cy > y){
01122 decode_gray_bitstream(s, width);
01123 ydst= p->data[0] + p->linesize[0]*y;
01124 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
01125 y++;
01126 }
01127 if(y>=height) break;
01128 }
01129 draw_slice(s, y);
01130
01131 decode_422_bitstream(s, width);
01132
01133 ydst= p->data[0] + p->linesize[0]*y;
01134 udst= p->data[1] + p->linesize[1]*cy;
01135 vdst= p->data[2] + p->linesize[2]*cy;
01136
01137 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
01138 if(!(s->flags&CODEC_FLAG_GRAY)){
01139 add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
01140 add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
01141 }
01142 }
01143
01144 draw_slice(s, height);
01145 break;
01146 }
01147 }
01148 }else{
01149 int y;
01150 int leftr, leftg, leftb;
01151 const int last_line= (height-1)*p->linesize[0];
01152
01153 if(s->bitstream_bpp==32){
01154 skip_bits(&s->gb, 8);
01155 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
01156 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
01157 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
01158 }else{
01159 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
01160 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
01161 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
01162 skip_bits(&s->gb, 8);
01163 }
01164
01165 if(s->bgr32){
01166 switch(s->predictor){
01167 case LEFT:
01168 case PLANE:
01169 decode_bgr_bitstream(s, width-1);
01170 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
01171
01172 for(y=s->height-2; y>=0; y--){
01173 decode_bgr_bitstream(s, width);
01174
01175 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
01176 if(s->predictor == PLANE){
01177 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
01178 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
01179 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
01180 }
01181 }
01182 }
01183 draw_slice(s, height);
01184 break;
01185 default:
01186 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
01187 }
01188 }else{
01189
01190 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
01191 return -1;
01192 }
01193 }
01194 emms_c();
01195
01196 *picture= *p;
01197 *data_size = sizeof(AVFrame);
01198
01199 return (get_bits_count(&s->gb)+31)/32*4 + table_size;
01200 }
01201 #endif
01202
01203 static int common_end(HYuvContext *s){
01204 int i;
01205
01206 for(i=0; i<3; i++){
01207 av_freep(&s->temp[i]);
01208 }
01209 return 0;
01210 }
01211
01212 #ifdef CONFIG_DECODERS
01213 static int decode_end(AVCodecContext *avctx)
01214 {
01215 HYuvContext *s = avctx->priv_data;
01216 int i;
01217
01218 common_end(s);
01219 av_freep(&s->bitstream_buffer);
01220
01221 for(i=0; i<6; i++){
01222 free_vlc(&s->vlc[i]);
01223 }
01224
01225 return 0;
01226 }
01227 #endif
01228
01229 #ifdef CONFIG_ENCODERS
01230 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
01231 HYuvContext *s = avctx->priv_data;
01232 AVFrame *pict = data;
01233 const int width= s->width;
01234 const int width2= s->width>>1;
01235 const int height= s->height;
01236 const int fake_ystride= s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
01237 const int fake_ustride= s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
01238 const int fake_vstride= s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
01239 AVFrame * const p= &s->picture;
01240 int i, j, size=0;
01241
01242 *p = *pict;
01243 p->pict_type= FF_I_TYPE;
01244 p->key_frame= 1;
01245
01246 if(s->context){
01247 for(i=0; i<3; i++){
01248 generate_len_table(s->len[i], s->stats[i], 256);
01249 if(generate_bits_table(s->bits[i], s->len[i])<0)
01250 return -1;
01251 size+= store_table(s, s->len[i], &buf[size]);
01252 }
01253
01254 for(i=0; i<3; i++)
01255 for(j=0; j<256; j++)
01256 s->stats[i][j] >>= 1;
01257 }
01258
01259 init_put_bits(&s->pb, buf+size, buf_size-size);
01260
01261 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
01262 int lefty, leftu, leftv, y, cy;
01263
01264 put_bits(&s->pb, 8, leftv= p->data[2][0]);
01265 put_bits(&s->pb, 8, lefty= p->data[0][1]);
01266 put_bits(&s->pb, 8, leftu= p->data[1][0]);
01267 put_bits(&s->pb, 8, p->data[0][0]);
01268
01269 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
01270 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
01271 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
01272
01273 encode_422_bitstream(s, width-2);
01274
01275 if(s->predictor==MEDIAN){
01276 int lefttopy, lefttopu, lefttopv;
01277 cy=y=1;
01278 if(s->interlaced){
01279 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
01280 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
01281 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
01282
01283 encode_422_bitstream(s, width);
01284 y++; cy++;
01285 }
01286
01287 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
01288 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
01289 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
01290
01291 encode_422_bitstream(s, 4);
01292
01293 lefttopy= p->data[0][3];
01294 lefttopu= p->data[1][1];
01295 lefttopv= p->data[2][1];
01296 s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
01297 s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
01298 s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
01299 encode_422_bitstream(s, width-4);
01300 y++; cy++;
01301
01302 for(; y<height; y++,cy++){
01303 uint8_t *ydst, *udst, *vdst;
01304
01305 if(s->bitstream_bpp==12){
01306 while(2*cy > y){
01307 ydst= p->data[0] + p->linesize[0]*y;
01308 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
01309 encode_gray_bitstream(s, width);
01310 y++;
01311 }
01312 if(y>=height) break;
01313 }
01314 ydst= p->data[0] + p->linesize[0]*y;
01315 udst= p->data[1] + p->linesize[1]*cy;
01316 vdst= p->data[2] + p->linesize[2]*cy;
01317
01318 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
01319 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
01320 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
01321
01322 encode_422_bitstream(s, width);
01323 }
01324 }else{
01325 for(cy=y=1; y<height; y++,cy++){
01326 uint8_t *ydst, *udst, *vdst;
01327
01328
01329 if(s->bitstream_bpp==12){
01330 ydst= p->data[0] + p->linesize[0]*y;
01331
01332 if(s->predictor == PLANE && s->interlaced < y){
01333 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
01334
01335 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
01336 }else{
01337 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
01338 }
01339 encode_gray_bitstream(s, width);
01340 y++;
01341 if(y>=height) break;
01342 }
01343
01344 ydst= p->data[0] + p->linesize[0]*y;
01345 udst= p->data[1] + p->linesize[1]*cy;
01346 vdst= p->data[2] + p->linesize[2]*cy;
01347
01348 if(s->predictor == PLANE && s->interlaced < cy){
01349 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
01350 s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
01351 s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
01352
01353 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
01354 leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
01355 leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
01356 }else{
01357 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
01358 leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
01359 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
01360 }
01361
01362 encode_422_bitstream(s, width);
01363 }
01364 }
01365 }else if(avctx->pix_fmt == PIX_FMT_RGB32){
01366 uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
01367 const int stride = -p->linesize[0];
01368 const int fake_stride = -fake_ystride;
01369 int y;
01370 int leftr, leftg, leftb;
01371
01372 put_bits(&s->pb, 8, leftr= data[R]);
01373 put_bits(&s->pb, 8, leftg= data[G]);
01374 put_bits(&s->pb, 8, leftb= data[B]);
01375 put_bits(&s->pb, 8, 0);
01376
01377 sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
01378 encode_bgr_bitstream(s, width-1);
01379
01380 for(y=1; y<s->height; y++){
01381 uint8_t *dst = data + y*stride;
01382 if(s->predictor == PLANE && s->interlaced < y){
01383 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
01384 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
01385 }else{
01386 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
01387 }
01388 encode_bgr_bitstream(s, width);
01389 }
01390 }else{
01391 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
01392 }
01393 emms_c();
01394
01395 size+= (put_bits_count(&s->pb)+31)/8;
01396 size/= 4;
01397
01398 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
01399 int j;
01400 char *p= avctx->stats_out;
01401 char *end= p + 1024*30;
01402 for(i=0; i<3; i++){
01403 for(j=0; j<256; j++){
01404 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
01405 p+= strlen(p);
01406 s->stats[i][j]= 0;
01407 }
01408 snprintf(p, end-p, "\n");
01409 p++;
01410 }
01411 } else
01412 avctx->stats_out[0] = '\0';
01413 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
01414 flush_put_bits(&s->pb);
01415 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
01416 }
01417
01418 s->picture_number++;
01419
01420 return size*4;
01421 }
01422
01423 static int encode_end(AVCodecContext *avctx)
01424 {
01425 HYuvContext *s = avctx->priv_data;
01426
01427 common_end(s);
01428
01429 av_freep(&avctx->extradata);
01430 av_freep(&avctx->stats_out);
01431
01432 return 0;
01433 }
01434 #endif
01435
01436 #ifdef CONFIG_DECODERS
01437 AVCodec huffyuv_decoder = {
01438 "huffyuv",
01439 CODEC_TYPE_VIDEO,
01440 CODEC_ID_HUFFYUV,
01441 sizeof(HYuvContext),
01442 decode_init,
01443 NULL,
01444 decode_end,
01445 decode_frame,
01446 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
01447 NULL
01448 };
01449
01450 AVCodec ffvhuff_decoder = {
01451 "ffvhuff",
01452 CODEC_TYPE_VIDEO,
01453 CODEC_ID_FFVHUFF,
01454 sizeof(HYuvContext),
01455 decode_init,
01456 NULL,
01457 decode_end,
01458 decode_frame,
01459 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
01460 NULL
01461 };
01462 #endif
01463
01464 #ifdef CONFIG_ENCODERS
01465
01466 AVCodec huffyuv_encoder = {
01467 "huffyuv",
01468 CODEC_TYPE_VIDEO,
01469 CODEC_ID_HUFFYUV,
01470 sizeof(HYuvContext),
01471 encode_init,
01472 encode_frame,
01473 encode_end,
01474 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
01475 };
01476
01477 AVCodec ffvhuff_encoder = {
01478 "ffvhuff",
01479 CODEC_TYPE_VIDEO,
01480 CODEC_ID_FFVHUFF,
01481 sizeof(HYuvContext),
01482 encode_init,
01483 encode_frame,
01484 encode_end,
01485 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
01486 };
01487
01488 #endif //CONFIG_ENCODERS