Mercurial > libavcodec.hg
comparison huffyuv.c @ 2967:ef2149182f1c libavcodec
COSMETICS: Remove all trailing whitespace.
author | diego |
---|---|
date | Sat, 17 Dec 2005 18:14:38 +0000 |
parents | fde28cb7e3d5 |
children | 0b546eab515d |
comparison
equal
deleted
inserted
replaced
2966:564788471dd4 | 2967:ef2149182f1c |
---|---|
16 * You should have received a copy of the GNU Lesser General Public | 16 * You should have received a copy of the GNU Lesser General Public |
17 * License along with this library; if not, write to the Free Software | 17 * License along with this library; if not, write to the Free Software |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
19 * | 19 * |
20 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of | 20 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of |
21 * the algorithm used | 21 * the algorithm used |
22 */ | 22 */ |
23 | 23 |
24 /** | 24 /** |
25 * @file huffyuv.c | 25 * @file huffyuv.c |
26 * huffyuv codec for libavcodec. | 26 * huffyuv codec for libavcodec. |
27 */ | 27 */ |
28 | 28 |
46 typedef enum Predictor{ | 46 typedef enum Predictor{ |
47 LEFT= 0, | 47 LEFT= 0, |
48 PLANE, | 48 PLANE, |
49 MEDIAN, | 49 MEDIAN, |
50 } Predictor; | 50 } Predictor; |
51 | 51 |
52 typedef struct HYuvContext{ | 52 typedef struct HYuvContext{ |
53 AVCodecContext *avctx; | 53 AVCodecContext *avctx; |
54 Predictor predictor; | 54 Predictor predictor; |
55 GetBitContext gb; | 55 GetBitContext gb; |
56 PutBitContext pb; | 56 PutBitContext pb; |
71 uint32_t bits[3][256]; | 71 uint32_t bits[3][256]; |
72 VLC vlc[3]; | 72 VLC vlc[3]; |
73 AVFrame picture; | 73 AVFrame picture; |
74 uint8_t *bitstream_buffer; | 74 uint8_t *bitstream_buffer; |
75 int bitstream_buffer_size; | 75 int bitstream_buffer_size; |
76 DSPContext dsp; | 76 DSPContext dsp; |
77 }HYuvContext; | 77 }HYuvContext; |
78 | 78 |
79 static const unsigned char classic_shift_luma[] = { | 79 static const unsigned char classic_shift_luma[] = { |
80 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8, | 80 34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8, |
81 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70, | 81 16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70, |
154 | 154 |
155 for(i=0; i<w; i++){ | 155 for(i=0; i<w; i++){ |
156 l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i]; | 156 l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i]; |
157 lt= src1[i]; | 157 lt= src1[i]; |
158 dst[i]= l; | 158 dst[i]= l; |
159 } | 159 } |
160 | 160 |
161 *left= l; | 161 *left= l; |
162 *left_top= lt; | 162 *left_top= lt; |
163 } | 163 } |
164 | 164 |
171 | 171 |
172 for(i=0; i<w; i++){ | 172 for(i=0; i<w; i++){ |
173 b+= src[4*i+B]; | 173 b+= src[4*i+B]; |
174 g+= src[4*i+G]; | 174 g+= src[4*i+G]; |
175 r+= src[4*i+R]; | 175 r+= src[4*i+R]; |
176 | 176 |
177 dst[4*i+B]= b; | 177 dst[4*i+B]= b; |
178 dst[4*i+G]= g; | 178 dst[4*i+G]= g; |
179 dst[4*i+R]= r; | 179 dst[4*i+R]= r; |
180 } | 180 } |
181 | 181 |
204 } | 204 } |
205 } | 205 } |
206 | 206 |
207 static void read_len_table(uint8_t *dst, GetBitContext *gb){ | 207 static void read_len_table(uint8_t *dst, GetBitContext *gb){ |
208 int i, val, repeat; | 208 int i, val, repeat; |
209 | 209 |
210 for(i=0; i<256;){ | 210 for(i=0; i<256;){ |
211 repeat= get_bits(gb, 3); | 211 repeat= get_bits(gb, 3); |
212 val = get_bits(gb, 5); | 212 val = get_bits(gb, 5); |
213 if(repeat==0) | 213 if(repeat==0) |
214 repeat= get_bits(gb, 8); | 214 repeat= get_bits(gb, 8); |
238 | 238 |
239 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){ | 239 static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){ |
240 uint64_t counts[2*size]; | 240 uint64_t counts[2*size]; |
241 int up[2*size]; | 241 int up[2*size]; |
242 int offset, i, next; | 242 int offset, i, next; |
243 | 243 |
244 for(offset=1; ; offset<<=1){ | 244 for(offset=1; ; offset<<=1){ |
245 for(i=0; i<size; i++){ | 245 for(i=0; i<size; i++){ |
246 counts[i]= stats[i] + offset - 1; | 246 counts[i]= stats[i] + offset - 1; |
247 } | 247 } |
248 | 248 |
249 for(next=size; next<size*2; next++){ | 249 for(next=size; next<size*2; next++){ |
250 uint64_t min1, min2; | 250 uint64_t min1, min2; |
251 int min1_i, min2_i; | 251 int min1_i, min2_i; |
252 | 252 |
253 min1=min2= INT64_MAX; | 253 min1=min2= INT64_MAX; |
254 min1_i= min2_i=-1; | 254 min1_i= min2_i=-1; |
255 | 255 |
256 for(i=0; i<next; i++){ | 256 for(i=0; i<next; i++){ |
257 if(min2 > counts[i]){ | 257 if(min2 > counts[i]){ |
258 if(min1 > counts[i]){ | 258 if(min1 > counts[i]){ |
259 min2= min1; | 259 min2= min1; |
260 min2_i= min1_i; | 260 min2_i= min1_i; |
264 min2= counts[i]; | 264 min2= counts[i]; |
265 min2_i= i; | 265 min2_i= i; |
266 } | 266 } |
267 } | 267 } |
268 } | 268 } |
269 | 269 |
270 if(min2==INT64_MAX) break; | 270 if(min2==INT64_MAX) break; |
271 | 271 |
272 counts[next]= min1 + min2; | 272 counts[next]= min1 + min2; |
273 counts[min1_i]= | 273 counts[min1_i]= |
274 counts[min2_i]= INT64_MAX; | 274 counts[min2_i]= INT64_MAX; |
275 up[min1_i]= | 275 up[min1_i]= |
276 up[min2_i]= next; | 276 up[min2_i]= next; |
277 up[next]= -1; | 277 up[next]= -1; |
278 } | 278 } |
279 | 279 |
280 for(i=0; i<size; i++){ | 280 for(i=0; i<size; i++){ |
281 int len; | 281 int len; |
282 int index=i; | 282 int index=i; |
283 | 283 |
284 for(len=0; up[index] != -1; len++) | 284 for(len=0; up[index] != -1; len++) |
285 index= up[index]; | 285 index= up[index]; |
286 | 286 |
287 if(len >= 32) break; | 287 if(len >= 32) break; |
288 | 288 |
289 dst[i]= len; | 289 dst[i]= len; |
290 } | 290 } |
291 if(i==size) break; | 291 if(i==size) break; |
292 } | 292 } |
293 } | 293 } |
294 | 294 |
295 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){ | 295 static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){ |
296 GetBitContext gb; | 296 GetBitContext gb; |
297 int i; | 297 int i; |
298 | 298 |
299 init_get_bits(&gb, src, length*8); | 299 init_get_bits(&gb, src, length*8); |
300 | 300 |
301 for(i=0; i<3; i++){ | 301 for(i=0; i<3; i++){ |
302 read_len_table(s->len[i], &gb); | 302 read_len_table(s->len[i], &gb); |
303 | 303 |
304 if(generate_bits_table(s->bits[i], s->len[i])<0){ | 304 if(generate_bits_table(s->bits[i], s->len[i])<0){ |
305 return -1; | 305 return -1; |
306 } | 306 } |
307 #if 0 | 307 #if 0 |
308 for(j=0; j<256; j++){ | 308 for(j=0; j<256; j++){ |
310 } | 310 } |
311 #endif | 311 #endif |
312 free_vlc(&s->vlc[i]); | 312 free_vlc(&s->vlc[i]); |
313 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0); | 313 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0); |
314 } | 314 } |
315 | 315 |
316 return (get_bits_count(&gb)+7)/8; | 316 return (get_bits_count(&gb)+7)/8; |
317 } | 317 } |
318 | 318 |
319 static int read_old_huffman_tables(HYuvContext *s){ | 319 static int read_old_huffman_tables(HYuvContext *s){ |
320 #if 1 | 320 #if 1 |
323 | 323 |
324 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8); | 324 init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8); |
325 read_len_table(s->len[0], &gb); | 325 read_len_table(s->len[0], &gb); |
326 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8); | 326 init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8); |
327 read_len_table(s->len[1], &gb); | 327 read_len_table(s->len[1], &gb); |
328 | 328 |
329 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i]; | 329 for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma [i]; |
330 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i]; | 330 for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i]; |
331 | 331 |
332 if(s->bitstream_bpp >= 24){ | 332 if(s->bitstream_bpp >= 24){ |
333 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t)); | 333 memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t)); |
334 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t)); | 334 memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t)); |
335 } | 335 } |
336 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t)); | 336 memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t)); |
337 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t)); | 337 memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t)); |
338 | 338 |
339 for(i=0; i<3; i++){ | 339 for(i=0; i<3; i++){ |
340 free_vlc(&s->vlc[i]); | 340 free_vlc(&s->vlc[i]); |
341 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0); | 341 init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0); |
342 } | 342 } |
343 | 343 |
344 return 0; | 344 return 0; |
345 #else | 345 #else |
346 fprintf(stderr, "v1 huffyuv is not supported \n"); | 346 fprintf(stderr, "v1 huffyuv is not supported \n"); |
347 return -1; | 347 return -1; |
348 #endif | 348 #endif |
349 } | 349 } |
350 | 350 |
351 static void alloc_temp(HYuvContext *s){ | 351 static void alloc_temp(HYuvContext *s){ |
352 int i; | 352 int i; |
353 | 353 |
354 if(s->bitstream_bpp<24){ | 354 if(s->bitstream_bpp<24){ |
355 for(i=0; i<3; i++){ | 355 for(i=0; i<3; i++){ |
356 s->temp[i]= av_malloc(s->width + 16); | 356 s->temp[i]= av_malloc(s->width + 16); |
357 } | 357 } |
358 }else{ | 358 }else{ |
363 static int common_init(AVCodecContext *avctx){ | 363 static int common_init(AVCodecContext *avctx){ |
364 HYuvContext *s = avctx->priv_data; | 364 HYuvContext *s = avctx->priv_data; |
365 | 365 |
366 s->avctx= avctx; | 366 s->avctx= avctx; |
367 s->flags= avctx->flags; | 367 s->flags= avctx->flags; |
368 | 368 |
369 dsputil_init(&s->dsp, avctx); | 369 dsputil_init(&s->dsp, avctx); |
370 | 370 |
371 s->width= avctx->width; | 371 s->width= avctx->width; |
372 s->height= avctx->height; | 372 s->height= avctx->height; |
373 assert(s->width>0 && s->height>0); | 373 assert(s->width>0 && s->height>0); |
374 | 374 |
375 return 0; | 375 return 0; |
376 } | 376 } |
377 | 377 |
378 static int decode_init(AVCodecContext *avctx) | 378 static int decode_init(AVCodecContext *avctx) |
379 { | 379 { |
380 HYuvContext *s = avctx->priv_data; | 380 HYuvContext *s = avctx->priv_data; |
381 | 381 |
382 common_init(avctx); | 382 common_init(avctx); |
383 memset(s->vlc, 0, 3*sizeof(VLC)); | 383 memset(s->vlc, 0, 3*sizeof(VLC)); |
384 | 384 |
385 avctx->coded_frame= &s->picture; | 385 avctx->coded_frame= &s->picture; |
386 s->interlaced= s->height > 288; | 386 s->interlaced= s->height > 288; |
387 | 387 |
388 s->bgr32=1; | 388 s->bgr32=1; |
389 //if(avctx->extradata) | 389 //if(avctx->extradata) |
393 s->version=1; // do such files exist at all? | 393 s->version=1; // do such files exist at all? |
394 else | 394 else |
395 s->version=2; | 395 s->version=2; |
396 }else | 396 }else |
397 s->version=0; | 397 s->version=0; |
398 | 398 |
399 if(s->version==2){ | 399 if(s->version==2){ |
400 int method, interlace; | 400 int method, interlace; |
401 | 401 |
402 method= ((uint8_t*)avctx->extradata)[0]; | 402 method= ((uint8_t*)avctx->extradata)[0]; |
403 s->decorrelate= method&64 ? 1 : 0; | 403 s->decorrelate= method&64 ? 1 : 0; |
404 s->predictor= method&63; | 404 s->predictor= method&63; |
405 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1]; | 405 s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1]; |
406 if(s->bitstream_bpp==0) | 406 if(s->bitstream_bpp==0) |
407 s->bitstream_bpp= avctx->bits_per_sample&~7; | 407 s->bitstream_bpp= avctx->bits_per_sample&~7; |
408 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4; | 408 interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4; |
409 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced; | 409 s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced; |
410 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0; | 410 s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0; |
411 | 411 |
412 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0) | 412 if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0) |
413 return -1; | 413 return -1; |
414 }else{ | 414 }else{ |
415 switch(avctx->bits_per_sample&7){ | 415 switch(avctx->bits_per_sample&7){ |
416 case 1: | 416 case 1: |
434 s->decorrelate= 0; | 434 s->decorrelate= 0; |
435 break; | 435 break; |
436 } | 436 } |
437 s->bitstream_bpp= avctx->bits_per_sample & ~7; | 437 s->bitstream_bpp= avctx->bits_per_sample & ~7; |
438 s->context= 0; | 438 s->context= 0; |
439 | 439 |
440 if(read_old_huffman_tables(s) < 0) | 440 if(read_old_huffman_tables(s) < 0) |
441 return -1; | 441 return -1; |
442 } | 442 } |
443 | 443 |
444 switch(s->bitstream_bpp){ | 444 switch(s->bitstream_bpp){ |
445 case 12: | 445 case 12: |
446 avctx->pix_fmt = PIX_FMT_YUV420P; | 446 avctx->pix_fmt = PIX_FMT_YUV420P; |
447 break; | 447 break; |
448 case 16: | 448 case 16: |
461 } | 461 } |
462 break; | 462 break; |
463 default: | 463 default: |
464 assert(0); | 464 assert(0); |
465 } | 465 } |
466 | 466 |
467 alloc_temp(s); | 467 alloc_temp(s); |
468 | 468 |
469 // av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced); | 469 // av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced); |
470 | 470 |
471 return 0; | 471 return 0; |
472 } | 472 } |
473 | 473 |
476 int index= 0; | 476 int index= 0; |
477 | 477 |
478 for(i=0; i<256;){ | 478 for(i=0; i<256;){ |
479 int val= len[i]; | 479 int val= len[i]; |
480 int repeat=0; | 480 int repeat=0; |
481 | 481 |
482 for(; i<256 && len[i]==val && repeat<255; i++) | 482 for(; i<256 && len[i]==val && repeat<255; i++) |
483 repeat++; | 483 repeat++; |
484 | 484 |
485 assert(val < 32 && val >0 && repeat<256 && repeat>0); | 485 assert(val < 32 && val >0 && repeat<256 && repeat>0); |
486 if(repeat>7){ | 486 if(repeat>7){ |
487 buf[index++]= val; | 487 buf[index++]= val; |
488 buf[index++]= repeat; | 488 buf[index++]= repeat; |
489 }else{ | 489 }else{ |
490 buf[index++]= val | (repeat<<5); | 490 buf[index++]= val | (repeat<<5); |
491 } | 491 } |
492 } | 492 } |
493 | 493 |
494 return index; | 494 return index; |
495 } | 495 } |
496 | 496 |
497 static int encode_init(AVCodecContext *avctx) | 497 static int encode_init(AVCodecContext *avctx) |
498 { | 498 { |
499 HYuvContext *s = avctx->priv_data; | 499 HYuvContext *s = avctx->priv_data; |
500 int i, j; | 500 int i, j; |
501 | 501 |
502 common_init(avctx); | 502 common_init(avctx); |
503 | 503 |
504 avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772 | 504 avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772 |
505 avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132 | 505 avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132 |
506 s->version=2; | 506 s->version=2; |
507 | 507 |
508 avctx->coded_frame= &s->picture; | 508 avctx->coded_frame= &s->picture; |
509 | 509 |
510 switch(avctx->pix_fmt){ | 510 switch(avctx->pix_fmt){ |
511 case PIX_FMT_YUV420P: | 511 case PIX_FMT_YUV420P: |
512 s->bitstream_bpp= 12; | 512 s->bitstream_bpp= 12; |
513 break; | 513 break; |
514 case PIX_FMT_YUV422P: | 514 case PIX_FMT_YUV422P: |
527 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){ | 527 if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){ |
528 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n"); | 528 av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n"); |
529 return -1; | 529 return -1; |
530 } | 530 } |
531 }else s->context= 0; | 531 }else s->context= 0; |
532 | 532 |
533 if(avctx->codec->id==CODEC_ID_HUFFYUV){ | 533 if(avctx->codec->id==CODEC_ID_HUFFYUV){ |
534 if(avctx->pix_fmt==PIX_FMT_YUV420P){ | 534 if(avctx->pix_fmt==PIX_FMT_YUV420P){ |
535 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n"); | 535 av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n"); |
536 return -1; | 536 return -1; |
537 } | 537 } |
543 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n"); | 543 av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n"); |
544 }else if(avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ | 544 }else if(avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ |
545 av_log(avctx, AV_LOG_ERROR, "This codec is under development; files encoded with it may not be decodable with future versions!!! Set vstrict=-2 / -strict -2 to use it anyway.\n"); | 545 av_log(avctx, AV_LOG_ERROR, "This codec is under development; files encoded with it may not be decodable with future versions!!! Set vstrict=-2 / -strict -2 to use it anyway.\n"); |
546 return -1; | 546 return -1; |
547 } | 547 } |
548 | 548 |
549 ((uint8_t*)avctx->extradata)[0]= s->predictor; | 549 ((uint8_t*)avctx->extradata)[0]= s->predictor; |
550 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp; | 550 ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp; |
551 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20; | 551 ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20; |
552 if(s->context) | 552 if(s->context) |
553 ((uint8_t*)avctx->extradata)[2]|= 0x40; | 553 ((uint8_t*)avctx->extradata)[2]|= 0x40; |
554 ((uint8_t*)avctx->extradata)[3]= 0; | 554 ((uint8_t*)avctx->extradata)[3]= 0; |
555 s->avctx->extradata_size= 4; | 555 s->avctx->extradata_size= 4; |
556 | 556 |
557 if(avctx->stats_in){ | 557 if(avctx->stats_in){ |
558 char *p= avctx->stats_in; | 558 char *p= avctx->stats_in; |
559 | 559 |
560 for(i=0; i<3; i++) | 560 for(i=0; i<3; i++) |
561 for(j=0; j<256; j++) | 561 for(j=0; j<256; j++) |
562 s->stats[i][j]= 1; | 562 s->stats[i][j]= 1; |
563 | 563 |
564 for(;;){ | 564 for(;;){ |
567 | 567 |
568 for(j=0; j<256; j++){ | 568 for(j=0; j<256; j++){ |
569 s->stats[i][j]+= strtol(p, &next, 0); | 569 s->stats[i][j]+= strtol(p, &next, 0); |
570 if(next==p) return -1; | 570 if(next==p) return -1; |
571 p=next; | 571 p=next; |
572 } | 572 } |
573 } | 573 } |
574 if(p[0]==0 || p[1]==0 || p[2]==0) break; | 574 if(p[0]==0 || p[1]==0 || p[2]==0) break; |
575 } | 575 } |
576 }else{ | 576 }else{ |
577 for(i=0; i<3; i++) | 577 for(i=0; i<3; i++) |
578 for(j=0; j<256; j++){ | 578 for(j=0; j<256; j++){ |
579 int d= FFMIN(j, 256-j); | 579 int d= FFMIN(j, 256-j); |
580 | 580 |
581 s->stats[i][j]= 100000000/(d+1); | 581 s->stats[i][j]= 100000000/(d+1); |
582 } | 582 } |
583 } | 583 } |
584 | 584 |
585 for(i=0; i<3; i++){ | 585 for(i=0; i<3; i++){ |
586 generate_len_table(s->len[i], s->stats[i], 256); | 586 generate_len_table(s->len[i], s->stats[i], 256); |
587 | 587 |
588 if(generate_bits_table(s->bits[i], s->len[i])<0){ | 588 if(generate_bits_table(s->bits[i], s->len[i])<0){ |
589 return -1; | 589 return -1; |
590 } | 590 } |
591 | 591 |
592 s->avctx->extradata_size+= | 592 s->avctx->extradata_size+= |
593 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]); | 593 store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]); |
594 } | 594 } |
595 | 595 |
596 if(s->context){ | 596 if(s->context){ |
604 }else{ | 604 }else{ |
605 for(i=0; i<3; i++) | 605 for(i=0; i<3; i++) |
606 for(j=0; j<256; j++) | 606 for(j=0; j<256; j++) |
607 s->stats[i][j]= 0; | 607 s->stats[i][j]= 0; |
608 } | 608 } |
609 | 609 |
610 // printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced); | 610 // printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced); |
611 | 611 |
612 alloc_temp(s); | 612 alloc_temp(s); |
613 | 613 |
614 s->picture_number=0; | 614 s->picture_number=0; |
618 | 618 |
619 static void decode_422_bitstream(HYuvContext *s, int count){ | 619 static void decode_422_bitstream(HYuvContext *s, int count){ |
620 int i; | 620 int i; |
621 | 621 |
622 count/=2; | 622 count/=2; |
623 | 623 |
624 for(i=0; i<count; i++){ | 624 for(i=0; i<count; i++){ |
625 s->temp[0][2*i ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); | 625 s->temp[0][2*i ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); |
626 s->temp[1][ i ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); | 626 s->temp[1][ i ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); |
627 s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); | 627 s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); |
628 s->temp[2][ i ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); | 628 s->temp[2][ i ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); |
629 } | 629 } |
630 } | 630 } |
631 | 631 |
632 static void decode_gray_bitstream(HYuvContext *s, int count){ | 632 static void decode_gray_bitstream(HYuvContext *s, int count){ |
633 int i; | 633 int i; |
634 | 634 |
635 count/=2; | 635 count/=2; |
636 | 636 |
637 for(i=0; i<count; i++){ | 637 for(i=0; i<count; i++){ |
638 s->temp[0][2*i ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); | 638 s->temp[0][2*i ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); |
639 s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); | 639 s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); |
640 } | 640 } |
641 } | 641 } |
642 | 642 |
643 static int encode_422_bitstream(HYuvContext *s, int count){ | 643 static int encode_422_bitstream(HYuvContext *s, int count){ |
644 int i; | 644 int i; |
645 | 645 |
646 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){ | 646 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){ |
647 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | 647 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); |
648 return -1; | 648 return -1; |
649 } | 649 } |
650 | 650 |
651 count/=2; | 651 count/=2; |
652 if(s->flags&CODEC_FLAG_PASS1){ | 652 if(s->flags&CODEC_FLAG_PASS1){ |
653 for(i=0; i<count; i++){ | 653 for(i=0; i<count; i++){ |
654 s->stats[0][ s->temp[0][2*i ] ]++; | 654 s->stats[0][ s->temp[0][2*i ] ]++; |
655 s->stats[1][ s->temp[1][ i ] ]++; | 655 s->stats[1][ s->temp[1][ i ] ]++; |
681 return 0; | 681 return 0; |
682 } | 682 } |
683 | 683 |
684 static int encode_gray_bitstream(HYuvContext *s, int count){ | 684 static int encode_gray_bitstream(HYuvContext *s, int count){ |
685 int i; | 685 int i; |
686 | 686 |
687 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){ | 687 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){ |
688 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); | 688 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); |
689 return -1; | 689 return -1; |
690 } | 690 } |
691 | 691 |
696 s->stats[0][ s->temp[0][2*i+1] ]++; | 696 s->stats[0][ s->temp[0][2*i+1] ]++; |
697 } | 697 } |
698 } | 698 } |
699 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT) | 699 if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT) |
700 return 0; | 700 return 0; |
701 | 701 |
702 if(s->context){ | 702 if(s->context){ |
703 for(i=0; i<count; i++){ | 703 for(i=0; i<count; i++){ |
704 s->stats[0][ s->temp[0][2*i ] ]++; | 704 s->stats[0][ s->temp[0][2*i ] ]++; |
705 put_bits(&s->pb, s->len[0][ s->temp[0][2*i ] ], s->bits[0][ s->temp[0][2*i ] ]); | 705 put_bits(&s->pb, s->len[0][ s->temp[0][2*i ] ], s->bits[0][ s->temp[0][2*i ] ]); |
706 s->stats[0][ s->temp[0][2*i+1] ]++; | 706 s->stats[0][ s->temp[0][2*i+1] ]++; |
719 int i; | 719 int i; |
720 | 720 |
721 if(s->decorrelate){ | 721 if(s->decorrelate){ |
722 if(s->bitstream_bpp==24){ | 722 if(s->bitstream_bpp==24){ |
723 for(i=0; i<count; i++){ | 723 for(i=0; i<count; i++){ |
724 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); | 724 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); |
725 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G]; | 725 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G]; |
726 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G]; | 726 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G]; |
727 } | 727 } |
728 }else{ | 728 }else{ |
729 for(i=0; i<count; i++){ | 729 for(i=0; i<count; i++){ |
730 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); | 730 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); |
731 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G]; | 731 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G]; |
732 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G]; | 732 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G]; |
733 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?! | 733 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?! |
734 } | 734 } |
735 } | 735 } |
736 }else{ | 736 }else{ |
737 if(s->bitstream_bpp==24){ | 737 if(s->bitstream_bpp==24){ |
738 for(i=0; i<count; i++){ | 738 for(i=0; i<count; i++){ |
739 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); | 739 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); |
740 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); | 740 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); |
741 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); | 741 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); |
742 } | 742 } |
743 }else{ | 743 }else{ |
744 for(i=0; i<count; i++){ | 744 for(i=0; i<count; i++){ |
745 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); | 745 s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); |
746 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); | 746 s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); |
747 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); | 747 s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); |
748 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?! | 748 get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?! |
749 } | 749 } |
750 } | 750 } |
751 } | 751 } |
752 } | 752 } |
753 | 753 |
754 static void draw_slice(HYuvContext *s, int y){ | 754 static void draw_slice(HYuvContext *s, int y){ |
755 int h, cy; | 755 int h, cy; |
756 int offset[4]; | 756 int offset[4]; |
757 | 757 |
758 if(s->avctx->draw_horiz_band==NULL) | 758 if(s->avctx->draw_horiz_band==NULL) |
759 return; | 759 return; |
760 | 760 |
761 h= y - s->last_slice_end; | 761 h= y - s->last_slice_end; |
762 y -= h; | 762 y -= h; |
763 | 763 |
764 if(s->bitstream_bpp==12){ | 764 if(s->bitstream_bpp==12){ |
765 cy= y>>1; | 765 cy= y>>1; |
766 }else{ | 766 }else{ |
767 cy= y; | 767 cy= y; |
768 } | 768 } |
772 offset[2] = s->picture.linesize[2]*cy; | 772 offset[2] = s->picture.linesize[2]*cy; |
773 offset[3] = 0; | 773 offset[3] = 0; |
774 emms_c(); | 774 emms_c(); |
775 | 775 |
776 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h); | 776 s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h); |
777 | 777 |
778 s->last_slice_end= y + h; | 778 s->last_slice_end= y + h; |
779 } | 779 } |
780 | 780 |
781 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ | 781 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ |
782 HYuvContext *s = avctx->priv_data; | 782 HYuvContext *s = avctx->priv_data; |
790 AVFrame *picture = data; | 790 AVFrame *picture = data; |
791 | 791 |
792 s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE); | 792 s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE); |
793 | 793 |
794 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4); | 794 s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4); |
795 | 795 |
796 if(p->data[0]) | 796 if(p->data[0]) |
797 avctx->release_buffer(avctx, p); | 797 avctx->release_buffer(avctx, p); |
798 | 798 |
799 p->reference= 0; | 799 p->reference= 0; |
800 if(avctx->get_buffer(avctx, p) < 0){ | 800 if(avctx->get_buffer(avctx, p) < 0){ |
801 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | 801 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
802 return -1; | 802 return -1; |
803 } | 803 } |
804 | 804 |
805 if(s->context){ | 805 if(s->context){ |
806 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size); | 806 table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size); |
807 if(table_size < 0) | 807 if(table_size < 0) |
808 return -1; | 808 return -1; |
809 } | 809 } |
811 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8); | 811 init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8); |
812 | 812 |
813 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0]; | 813 fake_ystride= s->interlaced ? p->linesize[0]*2 : p->linesize[0]; |
814 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1]; | 814 fake_ustride= s->interlaced ? p->linesize[1]*2 : p->linesize[1]; |
815 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2]; | 815 fake_vstride= s->interlaced ? p->linesize[2]*2 : p->linesize[2]; |
816 | 816 |
817 s->last_slice_end= 0; | 817 s->last_slice_end= 0; |
818 | 818 |
819 if(s->bitstream_bpp<24){ | 819 if(s->bitstream_bpp<24){ |
820 int y, cy; | 820 int y, cy; |
821 int lefty, leftu, leftv; | 821 int lefty, leftu, leftv; |
822 int lefttopy, lefttopu, lefttopv; | 822 int lefttopy, lefttopu, lefttopv; |
823 | 823 |
824 if(s->yuy2){ | 824 if(s->yuy2){ |
825 p->data[0][3]= get_bits(&s->gb, 8); | 825 p->data[0][3]= get_bits(&s->gb, 8); |
826 p->data[0][2]= get_bits(&s->gb, 8); | 826 p->data[0][2]= get_bits(&s->gb, 8); |
827 p->data[0][1]= get_bits(&s->gb, 8); | 827 p->data[0][1]= get_bits(&s->gb, 8); |
828 p->data[0][0]= get_bits(&s->gb, 8); | 828 p->data[0][0]= get_bits(&s->gb, 8); |
829 | 829 |
830 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n"); | 830 av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n"); |
831 return -1; | 831 return -1; |
832 }else{ | 832 }else{ |
833 | 833 |
834 leftv= p->data[2][0]= get_bits(&s->gb, 8); | 834 leftv= p->data[2][0]= get_bits(&s->gb, 8); |
835 lefty= p->data[0][1]= get_bits(&s->gb, 8); | 835 lefty= p->data[0][1]= get_bits(&s->gb, 8); |
836 leftu= p->data[1][0]= get_bits(&s->gb, 8); | 836 leftu= p->data[1][0]= get_bits(&s->gb, 8); |
837 p->data[0][0]= get_bits(&s->gb, 8); | 837 p->data[0][0]= get_bits(&s->gb, 8); |
838 | 838 |
839 switch(s->predictor){ | 839 switch(s->predictor){ |
840 case LEFT: | 840 case LEFT: |
841 case PLANE: | 841 case PLANE: |
842 decode_422_bitstream(s, width-2); | 842 decode_422_bitstream(s, width-2); |
843 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty); | 843 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty); |
846 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv); | 846 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv); |
847 } | 847 } |
848 | 848 |
849 for(cy=y=1; y<s->height; y++,cy++){ | 849 for(cy=y=1; y<s->height; y++,cy++){ |
850 uint8_t *ydst, *udst, *vdst; | 850 uint8_t *ydst, *udst, *vdst; |
851 | 851 |
852 if(s->bitstream_bpp==12){ | 852 if(s->bitstream_bpp==12){ |
853 decode_gray_bitstream(s, width); | 853 decode_gray_bitstream(s, width); |
854 | 854 |
855 ydst= p->data[0] + p->linesize[0]*y; | 855 ydst= p->data[0] + p->linesize[0]*y; |
856 | 856 |
857 lefty= add_left_prediction(ydst, s->temp[0], width, lefty); | 857 lefty= add_left_prediction(ydst, s->temp[0], width, lefty); |
858 if(s->predictor == PLANE){ | 858 if(s->predictor == PLANE){ |
859 if(y>s->interlaced) | 859 if(y>s->interlaced) |
860 s->dsp.add_bytes(ydst, ydst - fake_ystride, width); | 860 s->dsp.add_bytes(ydst, ydst - fake_ystride, width); |
861 } | 861 } |
862 y++; | 862 y++; |
863 if(y>=s->height) break; | 863 if(y>=s->height) break; |
864 } | 864 } |
865 | 865 |
866 draw_slice(s, y); | 866 draw_slice(s, y); |
867 | 867 |
868 ydst= p->data[0] + p->linesize[0]*y; | 868 ydst= p->data[0] + p->linesize[0]*y; |
869 udst= p->data[1] + p->linesize[1]*cy; | 869 udst= p->data[1] + p->linesize[1]*cy; |
870 vdst= p->data[2] + p->linesize[2]*cy; | 870 vdst= p->data[2] + p->linesize[2]*cy; |
871 | 871 |
872 decode_422_bitstream(s, width); | 872 decode_422_bitstream(s, width); |
873 lefty= add_left_prediction(ydst, s->temp[0], width, lefty); | 873 lefty= add_left_prediction(ydst, s->temp[0], width, lefty); |
874 if(!(s->flags&CODEC_FLAG_GRAY)){ | 874 if(!(s->flags&CODEC_FLAG_GRAY)){ |
875 leftu= add_left_prediction(udst, s->temp[1], width2, leftu); | 875 leftu= add_left_prediction(udst, s->temp[1], width2, leftu); |
876 leftv= add_left_prediction(vdst, s->temp[2], width2, leftv); | 876 leftv= add_left_prediction(vdst, s->temp[2], width2, leftv); |
884 } | 884 } |
885 } | 885 } |
886 } | 886 } |
887 } | 887 } |
888 draw_slice(s, height); | 888 draw_slice(s, height); |
889 | 889 |
890 break; | 890 break; |
891 case MEDIAN: | 891 case MEDIAN: |
892 /* first line except first 2 pixels is left predicted */ | 892 /* first line except first 2 pixels is left predicted */ |
893 decode_422_bitstream(s, width-2); | 893 decode_422_bitstream(s, width-2); |
894 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty); | 894 lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty); |
895 if(!(s->flags&CODEC_FLAG_GRAY)){ | 895 if(!(s->flags&CODEC_FLAG_GRAY)){ |
896 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu); | 896 leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu); |
897 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv); | 897 leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv); |
898 } | 898 } |
899 | 899 |
900 cy=y=1; | 900 cy=y=1; |
901 | 901 |
902 /* second line is left predicted for interlaced case */ | 902 /* second line is left predicted for interlaced case */ |
903 if(s->interlaced){ | 903 if(s->interlaced){ |
904 decode_422_bitstream(s, width); | 904 decode_422_bitstream(s, width); |
905 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty); | 905 lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty); |
906 if(!(s->flags&CODEC_FLAG_GRAY)){ | 906 if(!(s->flags&CODEC_FLAG_GRAY)){ |
927 lefttopv= p->data[2][1]; | 927 lefttopv= p->data[2][1]; |
928 add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu); | 928 add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu); |
929 add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv); | 929 add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv); |
930 } | 930 } |
931 y++; cy++; | 931 y++; cy++; |
932 | 932 |
933 for(; y<height; y++,cy++){ | 933 for(; y<height; y++,cy++){ |
934 uint8_t *ydst, *udst, *vdst; | 934 uint8_t *ydst, *udst, *vdst; |
935 | 935 |
936 if(s->bitstream_bpp==12){ | 936 if(s->bitstream_bpp==12){ |
937 while(2*cy > y){ | 937 while(2*cy > y){ |
963 } | 963 } |
964 }else{ | 964 }else{ |
965 int y; | 965 int y; |
966 int leftr, leftg, leftb; | 966 int leftr, leftg, leftb; |
967 const int last_line= (height-1)*p->linesize[0]; | 967 const int last_line= (height-1)*p->linesize[0]; |
968 | 968 |
969 if(s->bitstream_bpp==32){ | 969 if(s->bitstream_bpp==32){ |
970 skip_bits(&s->gb, 8); | 970 skip_bits(&s->gb, 8); |
971 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8); | 971 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8); |
972 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8); | 972 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8); |
973 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8); | 973 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8); |
975 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8); | 975 leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8); |
976 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8); | 976 leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8); |
977 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8); | 977 leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8); |
978 skip_bits(&s->gb, 8); | 978 skip_bits(&s->gb, 8); |
979 } | 979 } |
980 | 980 |
981 if(s->bgr32){ | 981 if(s->bgr32){ |
982 switch(s->predictor){ | 982 switch(s->predictor){ |
983 case LEFT: | 983 case LEFT: |
984 case PLANE: | 984 case PLANE: |
985 decode_bgr_bitstream(s, width-1); | 985 decode_bgr_bitstream(s, width-1); |
986 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb); | 986 add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb); |
987 | 987 |
988 for(y=s->height-2; y>=0; y--){ //yes its stored upside down | 988 for(y=s->height-2; y>=0; y--){ //yes its stored upside down |
989 decode_bgr_bitstream(s, width); | 989 decode_bgr_bitstream(s, width); |
990 | 990 |
991 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb); | 991 add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb); |
992 if(s->predictor == PLANE){ | 992 if(s->predictor == PLANE){ |
993 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){ | 993 if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){ |
994 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y, | 994 s->dsp.add_bytes(p->data[0] + p->linesize[0]*y, |
995 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride); | 995 p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride); |
996 } | 996 } |
997 } | 997 } |
998 } | 998 } |
999 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order | 999 draw_slice(s, height); // just 1 large slice as this is not possible in reverse order |
1006 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n"); | 1006 av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n"); |
1007 return -1; | 1007 return -1; |
1008 } | 1008 } |
1009 } | 1009 } |
1010 emms_c(); | 1010 emms_c(); |
1011 | 1011 |
1012 *picture= *p; | 1012 *picture= *p; |
1013 *data_size = sizeof(AVFrame); | 1013 *data_size = sizeof(AVFrame); |
1014 | 1014 |
1015 return (get_bits_count(&s->gb)+31)/32*4; | 1015 return (get_bits_count(&s->gb)+31)/32*4; |
1016 } | 1016 } |
1017 | 1017 |
1018 static int common_end(HYuvContext *s){ | 1018 static int common_end(HYuvContext *s){ |
1019 int i; | 1019 int i; |
1020 | 1020 |
1021 for(i=0; i<3; i++){ | 1021 for(i=0; i<3; i++){ |
1022 av_freep(&s->temp[i]); | 1022 av_freep(&s->temp[i]); |
1023 } | 1023 } |
1024 return 0; | 1024 return 0; |
1025 } | 1025 } |
1026 | 1026 |
1027 static int decode_end(AVCodecContext *avctx) | 1027 static int decode_end(AVCodecContext *avctx) |
1028 { | 1028 { |
1029 HYuvContext *s = avctx->priv_data; | 1029 HYuvContext *s = avctx->priv_data; |
1030 int i; | 1030 int i; |
1031 | 1031 |
1032 common_end(s); | 1032 common_end(s); |
1033 av_freep(&s->bitstream_buffer); | 1033 av_freep(&s->bitstream_buffer); |
1034 | 1034 |
1035 for(i=0; i<3; i++){ | 1035 for(i=0; i<3; i++){ |
1036 free_vlc(&s->vlc[i]); | 1036 free_vlc(&s->vlc[i]); |
1037 } | 1037 } |
1038 | 1038 |
1039 return 0; | 1039 return 0; |
1052 int i, j, size=0; | 1052 int i, j, size=0; |
1053 | 1053 |
1054 *p = *pict; | 1054 *p = *pict; |
1055 p->pict_type= FF_I_TYPE; | 1055 p->pict_type= FF_I_TYPE; |
1056 p->key_frame= 1; | 1056 p->key_frame= 1; |
1057 | 1057 |
1058 if(s->context){ | 1058 if(s->context){ |
1059 for(i=0; i<3; i++){ | 1059 for(i=0; i<3; i++){ |
1060 generate_len_table(s->len[i], s->stats[i], 256); | 1060 generate_len_table(s->len[i], s->stats[i], 256); |
1061 if(generate_bits_table(s->bits[i], s->len[i])<0) | 1061 if(generate_bits_table(s->bits[i], s->len[i])<0) |
1062 return -1; | 1062 return -1; |
1075 | 1075 |
1076 put_bits(&s->pb, 8, leftv= p->data[2][0]); | 1076 put_bits(&s->pb, 8, leftv= p->data[2][0]); |
1077 put_bits(&s->pb, 8, lefty= p->data[0][1]); | 1077 put_bits(&s->pb, 8, lefty= p->data[0][1]); |
1078 put_bits(&s->pb, 8, leftu= p->data[1][0]); | 1078 put_bits(&s->pb, 8, leftu= p->data[1][0]); |
1079 put_bits(&s->pb, 8, p->data[0][0]); | 1079 put_bits(&s->pb, 8, p->data[0][0]); |
1080 | 1080 |
1081 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty); | 1081 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty); |
1082 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu); | 1082 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu); |
1083 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv); | 1083 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv); |
1084 | 1084 |
1085 encode_422_bitstream(s, width-2); | 1085 encode_422_bitstream(s, width-2); |
1086 | 1086 |
1087 if(s->predictor==MEDIAN){ | 1087 if(s->predictor==MEDIAN){ |
1088 int lefttopy, lefttopu, lefttopv; | 1088 int lefttopy, lefttopu, lefttopv; |
1089 cy=y=1; | 1089 cy=y=1; |
1090 if(s->interlaced){ | 1090 if(s->interlaced){ |
1091 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty); | 1091 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty); |
1092 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu); | 1092 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu); |
1093 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv); | 1093 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv); |
1094 | 1094 |
1095 encode_422_bitstream(s, width); | 1095 encode_422_bitstream(s, width); |
1096 y++; cy++; | 1096 y++; cy++; |
1097 } | 1097 } |
1098 | 1098 |
1099 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty); | 1099 lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty); |
1100 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu); | 1100 leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu); |
1101 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv); | 1101 leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv); |
1102 | 1102 |
1103 encode_422_bitstream(s, 4); | 1103 encode_422_bitstream(s, 4); |
1104 | 1104 |
1105 lefttopy= p->data[0][3]; | 1105 lefttopy= p->data[0][3]; |
1106 lefttopu= p->data[1][1]; | 1106 lefttopu= p->data[1][1]; |
1107 lefttopv= p->data[2][1]; | 1107 lefttopv= p->data[2][1]; |
1111 encode_422_bitstream(s, width-4); | 1111 encode_422_bitstream(s, width-4); |
1112 y++; cy++; | 1112 y++; cy++; |
1113 | 1113 |
1114 for(; y<height; y++,cy++){ | 1114 for(; y<height; y++,cy++){ |
1115 uint8_t *ydst, *udst, *vdst; | 1115 uint8_t *ydst, *udst, *vdst; |
1116 | 1116 |
1117 if(s->bitstream_bpp==12){ | 1117 if(s->bitstream_bpp==12){ |
1118 while(2*cy > y){ | 1118 while(2*cy > y){ |
1119 ydst= p->data[0] + p->linesize[0]*y; | 1119 ydst= p->data[0] + p->linesize[0]*y; |
1120 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy); | 1120 s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy); |
1121 encode_gray_bitstream(s, width); | 1121 encode_gray_bitstream(s, width); |
1134 encode_422_bitstream(s, width); | 1134 encode_422_bitstream(s, width); |
1135 } | 1135 } |
1136 }else{ | 1136 }else{ |
1137 for(cy=y=1; y<height; y++,cy++){ | 1137 for(cy=y=1; y<height; y++,cy++){ |
1138 uint8_t *ydst, *udst, *vdst; | 1138 uint8_t *ydst, *udst, *vdst; |
1139 | 1139 |
1140 /* encode a luma only line & y++ */ | 1140 /* encode a luma only line & y++ */ |
1141 if(s->bitstream_bpp==12){ | 1141 if(s->bitstream_bpp==12){ |
1142 ydst= p->data[0] + p->linesize[0]*y; | 1142 ydst= p->data[0] + p->linesize[0]*y; |
1143 | 1143 |
1144 if(s->predictor == PLANE && s->interlaced < y){ | 1144 if(s->predictor == PLANE && s->interlaced < y){ |
1150 } | 1150 } |
1151 encode_gray_bitstream(s, width); | 1151 encode_gray_bitstream(s, width); |
1152 y++; | 1152 y++; |
1153 if(y>=height) break; | 1153 if(y>=height) break; |
1154 } | 1154 } |
1155 | 1155 |
1156 ydst= p->data[0] + p->linesize[0]*y; | 1156 ydst= p->data[0] + p->linesize[0]*y; |
1157 udst= p->data[1] + p->linesize[1]*cy; | 1157 udst= p->data[1] + p->linesize[1]*cy; |
1158 vdst= p->data[2] + p->linesize[2]*cy; | 1158 vdst= p->data[2] + p->linesize[2]*cy; |
1159 | 1159 |
1160 if(s->predictor == PLANE && s->interlaced < cy){ | 1160 if(s->predictor == PLANE && s->interlaced < cy){ |
1171 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv); | 1171 leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv); |
1172 } | 1172 } |
1173 | 1173 |
1174 encode_422_bitstream(s, width); | 1174 encode_422_bitstream(s, width); |
1175 } | 1175 } |
1176 } | 1176 } |
1177 }else{ | 1177 }else{ |
1178 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n"); | 1178 av_log(avctx, AV_LOG_ERROR, "Format not supported!\n"); |
1179 } | 1179 } |
1180 emms_c(); | 1180 emms_c(); |
1181 | 1181 |
1182 size+= (put_bits_count(&s->pb)+31)/8; | 1182 size+= (put_bits_count(&s->pb)+31)/8; |
1183 size/= 4; | 1183 size/= 4; |
1184 | 1184 |
1185 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){ | 1185 if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){ |
1186 int j; | 1186 int j; |
1187 char *p= avctx->stats_out; | 1187 char *p= avctx->stats_out; |
1188 char *end= p + 1024*30; | 1188 char *end= p + 1024*30; |
1189 for(i=0; i<3; i++){ | 1189 for(i=0; i<3; i++){ |
1199 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){ | 1199 if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){ |
1200 flush_put_bits(&s->pb); | 1200 flush_put_bits(&s->pb); |
1201 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size); | 1201 s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size); |
1202 avctx->stats_out[0] = '\0'; | 1202 avctx->stats_out[0] = '\0'; |
1203 } | 1203 } |
1204 | 1204 |
1205 s->picture_number++; | 1205 s->picture_number++; |
1206 | 1206 |
1207 return size*4; | 1207 return size*4; |
1208 } | 1208 } |
1209 | 1209 |
1210 static int encode_end(AVCodecContext *avctx) | 1210 static int encode_end(AVCodecContext *avctx) |
1211 { | 1211 { |
1212 HYuvContext *s = avctx->priv_data; | 1212 HYuvContext *s = avctx->priv_data; |
1213 | 1213 |
1214 common_end(s); | 1214 common_end(s); |
1215 | 1215 |
1216 av_freep(&avctx->extradata); | 1216 av_freep(&avctx->extradata); |
1217 av_freep(&avctx->stats_out); | 1217 av_freep(&avctx->stats_out); |
1218 | 1218 |
1219 return 0; | 1219 return 0; |
1220 } | 1220 } |
1221 | 1221 |
1222 AVCodec huffyuv_decoder = { | 1222 AVCodec huffyuv_decoder = { |
1223 "huffyuv", | 1223 "huffyuv", |