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 if(count >= (s->gb.size_in_bits - get_bits_count(&s->gb))/(31*4)){
00749 for(i=0; i<count && get_bits_count(&s->gb) < s->gb.size_in_bits; i++){
00750 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
00751 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
00752 }
00753 }else{
00754 for(i=0; i<count; i++){
00755 READ_2PIX(s->temp[0][2*i ], s->temp[1][i], 1);
00756 READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
00757 }
00758 }
00759 }
00760
00761 static void decode_gray_bitstream(HYuvContext *s, int count){
00762 int i;
00763
00764 count/=2;
00765
00766 if(count >= (s->gb.size_in_bits - get_bits_count(&s->gb))/(31*2)){
00767 for(i=0; i<count && get_bits_count(&s->gb) < s->gb.size_in_bits; i++){
00768 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
00769 }
00770 }else{
00771 for(i=0; i<count; i++){
00772 READ_2PIX(s->temp[0][2*i ], s->temp[0][2*i+1], 0);
00773 }
00774 }
00775 }
00776
00777 #ifdef CONFIG_ENCODERS
00778 static int encode_422_bitstream(HYuvContext *s, int count){
00779 int i;
00780
00781 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
00782 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00783 return -1;
00784 }
00785
00786 #define LOAD4\
00787 int y0 = s->temp[0][2*i];\
00788 int y1 = s->temp[0][2*i+1];\
00789 int u0 = s->temp[1][i];\
00790 int v0 = s->temp[2][i];
00791
00792 count/=2;
00793 if(s->flags&CODEC_FLAG_PASS1){
00794 for(i=0; i<count; i++){
00795 LOAD4;
00796 s->stats[0][y0]++;
00797 s->stats[1][u0]++;
00798 s->stats[0][y1]++;
00799 s->stats[2][v0]++;
00800 }
00801 }
00802 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
00803 return 0;
00804 if(s->context){
00805 for(i=0; i<count; i++){
00806 LOAD4;
00807 s->stats[0][y0]++;
00808 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
00809 s->stats[1][u0]++;
00810 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
00811 s->stats[0][y1]++;
00812 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00813 s->stats[2][v0]++;
00814 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
00815 }
00816 }else{
00817 for(i=0; i<count; i++){
00818 LOAD4;
00819 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
00820 put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
00821 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00822 put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
00823 }
00824 }
00825 return 0;
00826 }
00827
00828 static int encode_gray_bitstream(HYuvContext *s, int count){
00829 int i;
00830
00831 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
00832 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00833 return -1;
00834 }
00835
00836 #define LOAD2\
00837 int y0 = s->temp[0][2*i];\
00838 int y1 = s->temp[0][2*i+1];
00839 #define STAT2\
00840 s->stats[0][y0]++;\
00841 s->stats[0][y1]++;
00842 #define WRITE2\
00843 put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
00844 put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
00845
00846 count/=2;
00847 if(s->flags&CODEC_FLAG_PASS1){
00848 for(i=0; i<count; i++){
00849 LOAD2;
00850 STAT2;
00851 }
00852 }
00853 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
00854 return 0;
00855
00856 if(s->context){
00857 for(i=0; i<count; i++){
00858 LOAD2;
00859 STAT2;
00860 WRITE2;
00861 }
00862 }else{
00863 for(i=0; i<count; i++){
00864 LOAD2;
00865 WRITE2;
00866 }
00867 }
00868 return 0;
00869 }
00870 #endif
00871
00872 static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
00873 int i;
00874 for(i=0; i<count; i++){
00875 int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
00876 if(code != -1){
00877 *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
00878 }else if(decorrelate){
00879 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
00880 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
00881 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
00882 }else{
00883 s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
00884 s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
00885 s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
00886 }
00887 if(alpha)
00888 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
00889 }
00890 }
00891
00892 static void decode_bgr_bitstream(HYuvContext *s, int count){
00893 if(s->decorrelate){
00894 if(s->bitstream_bpp==24)
00895 decode_bgr_1(s, count, 1, 0);
00896 else
00897 decode_bgr_1(s, count, 1, 1);
00898 }else{
00899 if(s->bitstream_bpp==24)
00900 decode_bgr_1(s, count, 0, 0);
00901 else
00902 decode_bgr_1(s, count, 0, 1);
00903 }
00904 }
00905
00906 static int encode_bgr_bitstream(HYuvContext *s, int count){
00907 int i;
00908
00909 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
00910 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00911 return -1;
00912 }
00913
00914 #define LOAD3\
00915 int g= s->temp[0][4*i+G];\
00916 int b= (s->temp[0][4*i+B] - g) & 0xff;\
00917 int r= (s->temp[0][4*i+R] - g) & 0xff;
00918 #define STAT3\
00919 s->stats[0][b]++;\
00920 s->stats[1][g]++;\
00921 s->stats[2][r]++;
00922 #define WRITE3\
00923 put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
00924 put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
00925 put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
00926
00927 if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
00928 for(i=0; i<count; i++){
00929 LOAD3;
00930 STAT3;
00931 }
00932 }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
00933 for(i=0; i<count; i++){
00934 LOAD3;
00935 STAT3;
00936 WRITE3;
00937 }
00938 }else{
00939 for(i=0; i<count; i++){
00940 LOAD3;
00941 WRITE3;
00942 }
00943 }
00944 return 0;
00945 }
00946
00947 #ifdef CONFIG_DECODERS
00948 static void draw_slice(HYuvContext *s, int y){
00949 int h, cy;
00950 int offset[4];
00951
00952 if(s->avctx->draw_horiz_band==NULL)
00953 return;
00954
00955 h= y - s->last_slice_end;
00956 y -= h;
00957
00958 if(s->bitstream_bpp==12){
00959 cy= y>>1;
00960 }else{
00961 cy= y;
00962 }
00963
00964 offset[0] = s->picture.linesize[0]*y;
00965 offset[1] = s->picture.linesize[1]*cy;
00966 offset[2] = s->picture.linesize[2]*cy;
00967 offset[3] = 0;
00968 emms_c();
00969
00970 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
00971
00972 s->last_slice_end= y + h;
00973 }
00974
00975 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){
00976 HYuvContext *s = avctx->priv_data;
00977 const int width= s->width;
00978 const int width2= s->width>>1;
00979 const int height= s->height;
00980 int fake_ystride, fake_ustride, fake_vstride;
00981 AVFrame * const p= &s->picture;
00982 int table_size= 0;
00983
00984 AVFrame *picture = data;
00985
00986 s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
00987
00988 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
00989
00990 if(p->data[0])
00991 avctx->release_buffer(avctx, p);
00992
00993 p->reference= 0;
00994 if(avctx->get_buffer(avctx, p) < 0){
00995 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00996 return -1;
00997 }
00998
00999 if(s->context){
01000 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
01001 if(table_size < 0)
01002 return -1;
01003 }
01004
01005 if((unsigned)(buf_size-table_size) >= INT_MAX/8)
01006 return -1;
01007
01008 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
01009
01010 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0];
01011 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1];
01012 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2];
01013
01014 s->last_slice_end= 0;
01015
01016 if(s->bitstream_bpp<24){
01017 int y, cy;
01018 int lefty, leftu, leftv;
01019 int lefttopy, lefttopu, lefttopv;
01020
01021 if(s->yuy2){
01022 p->data[0][3]= get_bits(&s->gb, 8);
01023 p->data[0][2]= get_bits(&s->gb, 8);
01024 p->data[0][1]= get_bits(&s->gb, 8);
01025 p->data[0][0]= get_bits(&s->gb, 8);
01026
01027 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
01028 return -1;
01029 }else{
01030
01031 leftv= p->data[2][0]= get_bits(&s->gb, 8);
01032 lefty= p->data[0][1]= get_bits(&s->gb, 8);
01033 leftu= p->data[1][0]= get_bits(&s->gb, 8);
01034 p->data[0][0]= get_bits(&s->gb, 8);
01035
01036 switch(s->predictor){
01037 case LEFT:
01038 case PLANE:
01039 decode_422_bitstream(s, width-2);
01040 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
01041 if(!(s->flags&CODEC_FLAG_GRAY)){
01042 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
01043 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
01044 }
01045
01046 for(cy=y=1; y<s->height; y++,cy++){
01047 uint8_t *ydst, *udst, *vdst;
01048
01049 if(s->bitstream_bpp==12){
01050 decode_gray_bitstream(s, width);
01051
01052 ydst= p->data[0] + p->linesize[0]*y;
01053
01054 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
01055 if(s->predictor == PLANE){
01056 if(y>s->interlaced)
01057 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
01058 }
01059 y++;
01060 if(y>=s->height) break;
01061 }
01062
01063 draw_slice(s, y);
01064
01065 ydst= p->data[0] + p->linesize[0]*y;
01066 udst= p->data[1] + p->linesize[1]*cy;
01067 vdst= p->data[2] + p->linesize[2]*cy;
01068
01069 decode_422_bitstream(s, width);
01070 lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
01071 if(!(s->flags&CODEC_FLAG_GRAY)){
01072 leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
01073 leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
01074 }
01075 if(s->predictor == PLANE){
01076 if(cy>s->interlaced){
01077 s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
01078 if(!(s->flags&CODEC_FLAG_GRAY)){
01079 s->dsp.add_bytes(udst, udst - fake_ustride, width2);
01080 s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
01081 }
01082 }
01083 }
01084 }
01085 draw_slice(s, height);
01086
01087 break;
01088 case MEDIAN:
01089
01090 decode_422_bitstream(s, width-2);
01091 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
01092 if(!(s->flags&CODEC_FLAG_GRAY)){
01093 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
01094 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
01095 }
01096
01097 cy=y=1;
01098
01099
01100 if(s->interlaced){
01101 decode_422_bitstream(s, width);
01102 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
01103 if(!(s->flags&CODEC_FLAG_GRAY)){
01104 leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
01105 leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
01106 }
01107 y++; cy++;
01108 }
01109
01110
01111 decode_422_bitstream(s, 4);
01112 lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
01113 if(!(s->flags&CODEC_FLAG_GRAY)){
01114 leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
01115 leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
01116 }
01117
01118
01119 lefttopy= p->data[0][3];
01120 decode_422_bitstream(s, width-4);
01121 add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
01122 if(!(s->flags&CODEC_FLAG_GRAY)){
01123 lefttopu= p->data[1][1];
01124 lefttopv= p->data[2][1];
01125 add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
01126 add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
01127 }
01128 y++; cy++;
01129
01130 for(; y<height; y++,cy++){
01131 uint8_t *ydst, *udst, *vdst;
01132
01133 if(s->bitstream_bpp==12){
01134 while(2*cy > y){
01135 decode_gray_bitstream(s, width);
01136 ydst= p->data[0] + p->linesize[0]*y;
01137 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
01138 y++;
01139 }
01140 if(y>=height) break;
01141 }
01142 draw_slice(s, y);
01143
01144 decode_422_bitstream(s, width);
01145
01146 ydst= p->data[0] + p->linesize[0]*y;
01147 udst= p->data[1] + p->linesize[1]*cy;
01148 vdst= p->data[2] + p->linesize[2]*cy;
01149
01150 add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
01151 if(!(s->flags&CODEC_FLAG_GRAY)){
01152 add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
01153 add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
01154 }
01155 }
01156
01157 draw_slice(s, height);
01158 break;
01159 }
01160 }
01161 }else{
01162 int y;
01163 int leftr, leftg, leftb;
01164 const int last_line= (height-1)*p->linesize[0];
01165
01166 if(s->bitstream_bpp==32){
01167 skip_bits(&s->gb, 8);
01168 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
01169 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
01170 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
01171 }else{
01172 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
01173 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
01174 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
01175 skip_bits(&s->gb, 8);
01176 }
01177
01178 if(s->bgr32){
01179 switch(s->predictor){
01180 case LEFT:
01181 case PLANE:
01182 decode_bgr_bitstream(s, width-1);
01183 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
01184
01185 for(y=s->height-2; y>=0; y--){
01186 decode_bgr_bitstream(s, width);
01187
01188 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
01189 if(s->predictor == PLANE){
01190 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
01191 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
01192 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
01193 }
01194 }
01195 }
01196 draw_slice(s, height);
01197 break;
01198 default:
01199 av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
01200 }
01201 }else{
01202
01203 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
01204 return -1;
01205 }
01206 }
01207 emms_c();
01208
01209 *picture= *p;
01210 *data_size = sizeof(AVFrame);
01211
01212 return (get_bits_count(&s->gb)+31)/32*4 + table_size;
01213 }
01214 #endif
01215
01216 static int common_end(HYuvContext *s){
01217 int i;
01218
01219 for(i=0; i<3; i++){
01220 av_freep(&s->temp[i]);
01221 }
01222 return 0;
01223 }
01224
01225 #ifdef CONFIG_DECODERS
01226 static int decode_end(AVCodecContext *avctx)
01227 {
01228 HYuvContext *s = avctx->priv_data;
01229 int i;
01230
01231 common_end(s);
01232 av_freep(&s->bitstream_buffer);
01233
01234 for(i=0; i<6; i++){
01235 free_vlc(&s->vlc[i]);
01236 }
01237
01238 return 0;
01239 }
01240 #endif
01241
01242 #ifdef CONFIG_ENCODERS
01243 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
01244 HYuvContext *s = avctx->priv_data;
01245 AVFrame *pict = data;
01246 const int width= s->width;
01247 const int width2= s->width>>1;
01248 const int height= s->height;
01249 const int fake_ystride= s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
01250 const int fake_ustride= s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
01251 const int fake_vstride= s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
01252 AVFrame * const p= &s->picture;
01253 int i, j, size=0;
01254
01255 *p = *pict;
01256 p->pict_type= FF_I_TYPE;
01257 p->key_frame= 1;
01258
01259 if(s->context){
01260 for(i=0; i<3; i++){
01261 generate_len_table(s->len[i], s->stats[i], 256);
01262 if(generate_bits_table(s->bits[i], s->len[i])<0)
01263 return -1;
01264 size+= store_table(s, s->len[i], &buf[size]);
01265 }
01266
01267 for(i=0; i<3; i++)
01268 for(j=0; j<256; j++)
01269 s->stats[i][j] >>= 1;
01270 }
01271
01272 init_put_bits(&s->pb, buf+size, buf_size-size);
01273
01274 if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
01275 int lefty, leftu, leftv, y, cy;
01276
01277 put_bits(&s->pb, 8, leftv= p->data[2][0]);
01278 put_bits(&s->pb, 8, lefty= p->data[0][1]);
01279 put_bits(&s->pb, 8, leftu= p->data[1][0]);
01280 put_bits(&s->pb, 8, p->data[0][0]);
01281
01282 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
01283 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
01284 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
01285
01286 encode_422_bitstream(s, width-2);
01287
01288 if(s->predictor==MEDIAN){
01289 int lefttopy, lefttopu, lefttopv;
01290 cy=y=1;
01291 if(s->interlaced){
01292 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
01293 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
01294 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
01295
01296 encode_422_bitstream(s, width);
01297 y++; cy++;
01298 }
01299
01300 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
01301 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
01302 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
01303
01304 encode_422_bitstream(s, 4);
01305
01306 lefttopy= p->data[0][3];
01307 lefttopu= p->data[1][1];
01308 lefttopv= p->data[2][1];
01309 s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
01310 s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
01311 s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
01312 encode_422_bitstream(s, width-4);
01313 y++; cy++;
01314
01315 for(; y<height; y++,cy++){
01316 uint8_t *ydst, *udst, *vdst;
01317
01318 if(s->bitstream_bpp==12){
01319 while(2*cy > y){
01320 ydst= p->data[0] + p->linesize[0]*y;
01321 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
01322 encode_gray_bitstream(s, width);
01323 y++;
01324 }
01325 if(y>=height) break;
01326 }
01327 ydst= p->data[0] + p->linesize[0]*y;
01328 udst= p->data[1] + p->linesize[1]*cy;
01329 vdst= p->data[2] + p->linesize[2]*cy;
01330
01331 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
01332 s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
01333 s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
01334
01335 encode_422_bitstream(s, width);
01336 }
01337 }else{
01338 for(cy=y=1; y<height; y++,cy++){
01339 uint8_t *ydst, *udst, *vdst;
01340
01341
01342 if(s->bitstream_bpp==12){
01343 ydst= p->data[0] + p->linesize[0]*y;
01344
01345 if(s->predictor == PLANE && s->interlaced < y){
01346 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
01347
01348 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
01349 }else{
01350 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
01351 }
01352 encode_gray_bitstream(s, width);
01353 y++;
01354 if(y>=height) break;
01355 }
01356
01357 ydst= p->data[0] + p->linesize[0]*y;
01358 udst= p->data[1] + p->linesize[1]*cy;
01359 vdst= p->data[2] + p->linesize[2]*cy;
01360
01361 if(s->predictor == PLANE && s->interlaced < cy){
01362 s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
01363 s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
01364 s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
01365
01366 lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
01367 leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
01368 leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
01369 }else{
01370 lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
01371 leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
01372 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
01373 }
01374
01375 encode_422_bitstream(s, width);
01376 }
01377 }
01378 }else if(avctx->pix_fmt == PIX_FMT_RGB32){
01379 uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
01380 const int stride = -p->linesize[0];
01381 const int fake_stride = -fake_ystride;
01382 int y;
01383 int leftr, leftg, leftb;
01384
01385 put_bits(&s->pb, 8, leftr= data[R]);
01386 put_bits(&s->pb, 8, leftg= data[G]);
01387 put_bits(&s->pb, 8, leftb= data[B]);
01388 put_bits(&s->pb, 8, 0);
01389
01390 sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
01391 encode_bgr_bitstream(s, width-1);
01392
01393 for(y=1; y<s->height; y++){
01394 uint8_t *dst = data + y*stride;
01395 if(s->predictor == PLANE && s->interlaced < y){
01396 s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
01397 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
01398 }else{
01399 sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
01400 }
01401 encode_bgr_bitstream(s, width);
01402 }
01403 }else{
01404 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
01405 }
01406 emms_c();
01407
01408 size+= (put_bits_count(&s->pb)+31)/8;
01409 size/= 4;
01410
01411 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
01412 int j;
01413 char *p= avctx->stats_out;
01414 char *end= p + 1024*30;
01415 for(i=0; i<3; i++){
01416 for(j=0; j<256; j++){
01417 snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
01418 p+= strlen(p);
01419 s->stats[i][j]= 0;
01420 }
01421 snprintf(p, end-p, "\n");
01422 p++;
01423 }
01424 } else
01425 avctx->stats_out[0] = '\0';
01426 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
01427 flush_put_bits(&s->pb);
01428 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
01429 }
01430
01431 s->picture_number++;
01432
01433 return size*4;
01434 }
01435
01436 static int encode_end(AVCodecContext *avctx)
01437 {
01438 HYuvContext *s = avctx->priv_data;
01439
01440 common_end(s);
01441
01442 av_freep(&avctx->extradata);
01443 av_freep(&avctx->stats_out);
01444
01445 return 0;
01446 }
01447 #endif
01448
01449 #ifdef CONFIG_DECODERS
01450 AVCodec huffyuv_decoder = {
01451 "huffyuv",
01452 CODEC_TYPE_VIDEO,
01453 CODEC_ID_HUFFYUV,
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
01463 AVCodec ffvhuff_decoder = {
01464 "ffvhuff",
01465 CODEC_TYPE_VIDEO,
01466 CODEC_ID_FFVHUFF,
01467 sizeof(HYuvContext),
01468 decode_init,
01469 NULL,
01470 decode_end,
01471 decode_frame,
01472 CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
01473 NULL
01474 };
01475 #endif
01476
01477 #ifdef CONFIG_ENCODERS
01478
01479 AVCodec huffyuv_encoder = {
01480 "huffyuv",
01481 CODEC_TYPE_VIDEO,
01482 CODEC_ID_HUFFYUV,
01483 sizeof(HYuvContext),
01484 encode_init,
01485 encode_frame,
01486 encode_end,
01487 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
01488 };
01489
01490 AVCodec ffvhuff_encoder = {
01491 "ffvhuff",
01492 CODEC_TYPE_VIDEO,
01493 CODEC_ID_FFVHUFF,
01494 sizeof(HYuvContext),
01495 encode_init,
01496 encode_frame,
01497 encode_end,
01498 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
01499 };
01500
01501 #endif //CONFIG_ENCODERS