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