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