Revision d375c104 libavcodec/mpegvideo.c
| libavcodec/mpegvideo.c | ||
|---|---|---|
| 38 | 38 |
#include "msmpeg4.h" |
| 39 | 39 |
#include "faandct.h" |
| 40 | 40 |
#include "xvmc_internal.h" |
| 41 |
#include "thread.h" |
|
| 41 | 42 |
#include <limits.h> |
| 42 | 43 |
|
| 43 | 44 |
//#undef NDEBUG |
| ... | ... | |
| 205 | 206 |
*/ |
| 206 | 207 |
static void free_frame_buffer(MpegEncContext *s, Picture *pic) |
| 207 | 208 |
{
|
| 208 |
s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
|
|
| 209 |
ff_thread_release_buffer(s->avctx, (AVFrame*)pic);
|
|
| 209 | 210 |
av_freep(&pic->hwaccel_picture_private); |
| 210 | 211 |
} |
| 211 | 212 |
|
| ... | ... | |
| 227 | 228 |
} |
| 228 | 229 |
} |
| 229 | 230 |
|
| 230 |
r = s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
|
|
| 231 |
r = ff_thread_get_buffer(s->avctx, (AVFrame*)pic);
|
|
| 231 | 232 |
|
| 232 | 233 |
if (r<0 || !pic->age || !pic->type || !pic->data[0]) {
|
| 233 | 234 |
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); |
| ... | ... | |
| 458 | 459 |
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
|
| 459 | 460 |
} |
| 460 | 461 |
|
| 462 |
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src) |
|
| 463 |
{
|
|
| 464 |
MpegEncContext *s = dst->priv_data, *s1 = src->priv_data; |
|
| 465 |
|
|
| 466 |
if(dst == src || !s1->context_initialized) return 0; |
|
| 467 |
|
|
| 468 |
//FIXME can parameters change on I-frames? in that case dst may need a reinit |
|
| 469 |
if(!s->context_initialized){
|
|
| 470 |
memcpy(s, s1, sizeof(MpegEncContext)); |
|
| 471 |
|
|
| 472 |
s->avctx = dst; |
|
| 473 |
s->picture_range_start += MAX_PICTURE_COUNT; |
|
| 474 |
s->picture_range_end += MAX_PICTURE_COUNT; |
|
| 475 |
s->bitstream_buffer = NULL; |
|
| 476 |
s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0; |
|
| 477 |
|
|
| 478 |
MPV_common_init(s); |
|
| 479 |
} |
|
| 480 |
|
|
| 481 |
s->avctx->coded_height = s1->avctx->coded_height; |
|
| 482 |
s->avctx->coded_width = s1->avctx->coded_width; |
|
| 483 |
s->avctx->width = s1->avctx->width; |
|
| 484 |
s->avctx->height = s1->avctx->height; |
|
| 485 |
|
|
| 486 |
s->coded_picture_number = s1->coded_picture_number; |
|
| 487 |
s->picture_number = s1->picture_number; |
|
| 488 |
s->input_picture_number = s1->input_picture_number; |
|
| 489 |
|
|
| 490 |
memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture)); |
|
| 491 |
memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture); |
|
| 492 |
|
|
| 493 |
s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1); |
|
| 494 |
s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1); |
|
| 495 |
s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1); |
|
| 496 |
|
|
| 497 |
memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); |
|
| 498 |
|
|
| 499 |
//Error/bug resilience |
|
| 500 |
s->next_p_frame_damaged = s1->next_p_frame_damaged; |
|
| 501 |
s->workaround_bugs = s1->workaround_bugs; |
|
| 502 |
|
|
| 503 |
//MPEG4 timing info |
|
| 504 |
memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits); |
|
| 505 |
|
|
| 506 |
//B-frame info |
|
| 507 |
s->max_b_frames = s1->max_b_frames; |
|
| 508 |
s->low_delay = s1->low_delay; |
|
| 509 |
s->dropable = s1->dropable; |
|
| 510 |
|
|
| 511 |
//DivX handling (doesn't work) |
|
| 512 |
s->divx_packed = s1->divx_packed; |
|
| 513 |
|
|
| 514 |
if(s1->bitstream_buffer){
|
|
| 515 |
if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size) |
|
| 516 |
av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size); |
|
| 517 |
s->bitstream_buffer_size = s1->bitstream_buffer_size; |
|
| 518 |
memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size); |
|
| 519 |
memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); |
|
| 520 |
} |
|
| 521 |
|
|
| 522 |
//MPEG2/interlacing info |
|
| 523 |
memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence); |
|
| 524 |
|
|
| 525 |
if(!s1->first_field){
|
|
| 526 |
s->last_pict_type= s1->pict_type; |
|
| 527 |
if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->quality; |
|
| 528 |
|
|
| 529 |
if(s1->pict_type!=FF_B_TYPE){
|
|
| 530 |
s->last_non_b_pict_type= s1->pict_type; |
|
| 531 |
} |
|
| 532 |
} |
|
| 533 |
|
|
| 534 |
return 0; |
|
| 535 |
} |
|
| 536 |
|
|
| 461 | 537 |
/** |
| 462 | 538 |
* sets the given MpegEncContext to common defaults (same for encoding and decoding). |
| 463 | 539 |
* the changed fields will not depend upon the prior state of the MpegEncContext. |
| ... | ... | |
| 478 | 554 |
|
| 479 | 555 |
s->f_code = 1; |
| 480 | 556 |
s->b_code = 1; |
| 557 |
|
|
| 558 |
s->picture_range_start = 0; |
|
| 559 |
s->picture_range_end = MAX_PICTURE_COUNT; |
|
| 481 | 560 |
} |
| 482 | 561 |
|
| 483 | 562 |
/** |
| ... | ... | |
| 506 | 585 |
return -1; |
| 507 | 586 |
} |
| 508 | 587 |
|
| 509 |
if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
|
|
| 588 |
if(s->avctx->active_thread_type&FF_THREAD_SLICE && |
|
| 589 |
(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
|
|
| 510 | 590 |
av_log(s->avctx, AV_LOG_ERROR, "too many threads\n"); |
| 511 | 591 |
return -1; |
| 512 | 592 |
} |
| ... | ... | |
| 599 | 679 |
FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail) |
| 600 | 680 |
} |
| 601 | 681 |
} |
| 602 |
FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, MAX_PICTURE_COUNT * sizeof(Picture), fail) |
|
| 603 |
for(i = 0; i < MAX_PICTURE_COUNT; i++) {
|
|
| 682 |
s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count); |
|
| 683 |
FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail) |
|
| 684 |
for(i = 0; i < s->picture_count; i++) {
|
|
| 604 | 685 |
avcodec_get_frame_defaults((AVFrame *)&s->picture[i]); |
| 605 | 686 |
} |
| 606 | 687 |
|
| ... | ... | |
| 660 | 741 |
} |
| 661 | 742 |
|
| 662 | 743 |
s->context_initialized = 1; |
| 663 |
|
|
| 664 | 744 |
s->thread_context[0]= s; |
| 665 |
threads = s->avctx->thread_count; |
|
| 666 | 745 |
|
| 667 |
for(i=1; i<threads; i++){
|
|
| 668 |
s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); |
|
| 669 |
memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); |
|
| 670 |
} |
|
| 746 |
if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
|
|
| 747 |
threads = s->avctx->thread_count; |
|
| 671 | 748 |
|
| 672 |
for(i=0; i<threads; i++){
|
|
| 673 |
if(init_duplicate_context(s->thread_context[i], s) < 0) |
|
| 674 |
goto fail; |
|
| 675 |
s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; |
|
| 676 |
s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; |
|
| 749 |
for(i=1; i<threads; i++){
|
|
| 750 |
s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); |
|
| 751 |
memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); |
|
| 752 |
} |
|
| 753 |
|
|
| 754 |
for(i=0; i<threads; i++){
|
|
| 755 |
if(init_duplicate_context(s->thread_context[i], s) < 0) |
|
| 756 |
goto fail; |
|
| 757 |
s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; |
|
| 758 |
s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; |
|
| 759 |
} |
|
| 760 |
} else {
|
|
| 761 |
if(init_duplicate_context(s, s) < 0) goto fail; |
|
| 762 |
s->start_mb_y = 0; |
|
| 763 |
s->end_mb_y = s->mb_height; |
|
| 677 | 764 |
} |
| 678 | 765 |
|
| 679 | 766 |
return 0; |
| ... | ... | |
| 687 | 774 |
{
|
| 688 | 775 |
int i, j, k; |
| 689 | 776 |
|
| 690 |
for(i=0; i<s->avctx->thread_count; i++){
|
|
| 691 |
free_duplicate_context(s->thread_context[i]); |
|
| 692 |
} |
|
| 693 |
for(i=1; i<s->avctx->thread_count; i++){
|
|
| 694 |
av_freep(&s->thread_context[i]); |
|
| 695 |
} |
|
| 777 |
if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
|
|
| 778 |
for(i=0; i<s->avctx->thread_count; i++){
|
|
| 779 |
free_duplicate_context(s->thread_context[i]); |
|
| 780 |
} |
|
| 781 |
for(i=1; i<s->avctx->thread_count; i++){
|
|
| 782 |
av_freep(&s->thread_context[i]); |
|
| 783 |
} |
|
| 784 |
} else free_duplicate_context(s); |
|
| 696 | 785 |
|
| 697 | 786 |
av_freep(&s->parse_context.buffer); |
| 698 | 787 |
s->parse_context.buffer_size=0; |
| ... | ... | |
| 747 | 836 |
av_freep(&s->reordered_input_picture); |
| 748 | 837 |
av_freep(&s->dct_offset); |
| 749 | 838 |
|
| 750 |
if(s->picture){
|
|
| 751 |
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
|
| 839 |
if(s->picture && !s->avctx->is_copy){
|
|
| 840 |
for(i=0; i<s->picture_count; i++){
|
|
| 752 | 841 |
free_picture(s, &s->picture[i]); |
| 753 | 842 |
} |
| 754 | 843 |
} |
| ... | ... | |
| 762 | 851 |
for(i=0; i<3; i++) |
| 763 | 852 |
av_freep(&s->visualization_buffer[i]); |
| 764 | 853 |
|
| 765 |
avcodec_default_free_buffers(s->avctx); |
|
| 854 |
if(!(s->avctx->active_thread_type&FF_THREAD_FRAME)) |
|
| 855 |
avcodec_default_free_buffers(s->avctx); |
|
| 766 | 856 |
} |
| 767 | 857 |
|
| 768 | 858 |
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3]) |
| ... | ... | |
| 860 | 950 |
int i; |
| 861 | 951 |
|
| 862 | 952 |
if(shared){
|
| 863 |
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
|
| 953 |
for(i=s->picture_range_start; i<s->picture_range_end; i++){
|
|
| 864 | 954 |
if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; |
| 865 | 955 |
} |
| 866 | 956 |
}else{
|
| 867 |
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
|
| 957 |
for(i=s->picture_range_start; i<s->picture_range_end; i++){
|
|
| 868 | 958 |
if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME |
| 869 | 959 |
} |
| 870 |
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
|
| 960 |
for(i=s->picture_range_start; i<s->picture_range_end; i++){
|
|
| 871 | 961 |
if(s->picture[i].data[0]==NULL) return i; |
| 872 | 962 |
} |
| 873 | 963 |
} |
| ... | ... | |
| 924 | 1014 |
/* release forgotten pictures */ |
| 925 | 1015 |
/* if(mpeg124/h263) */ |
| 926 | 1016 |
if(!s->encoding){
|
| 927 |
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
|
| 1017 |
for(i=0; i<s->picture_count; i++){
|
|
| 928 | 1018 |
if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
|
| 929 | 1019 |
av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); |
| 930 | 1020 |
free_frame_buffer(s, &s->picture[i]); |
| ... | ... | |
| 936 | 1026 |
|
| 937 | 1027 |
if(!s->encoding){
|
| 938 | 1028 |
/* release non reference frames */ |
| 939 |
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
|
| 1029 |
for(i=0; i<s->picture_count; i++){
|
|
| 940 | 1030 |
if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
|
| 941 | 1031 |
free_frame_buffer(s, &s->picture[i]); |
| 942 | 1032 |
} |
| ... | ... | |
| 970 | 1060 |
s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field; |
| 971 | 1061 |
} |
| 972 | 1062 |
s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; |
| 1063 |
s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME; |
|
| 973 | 1064 |
} |
| 974 | 1065 |
|
| 975 | 1066 |
s->current_picture_ptr->pict_type= s->pict_type; |
| ... | ... | |
| 998 | 1089 |
s->last_picture_ptr= &s->picture[i]; |
| 999 | 1090 |
if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) |
| 1000 | 1091 |
return -1; |
| 1092 |
ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0); |
|
| 1093 |
ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1); |
|
| 1001 | 1094 |
} |
| 1002 | 1095 |
if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==FF_B_TYPE){
|
| 1003 | 1096 |
/* Allocate a dummy frame */ |
| ... | ... | |
| 1005 | 1098 |
s->next_picture_ptr= &s->picture[i]; |
| 1006 | 1099 |
if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) |
| 1007 | 1100 |
return -1; |
| 1101 |
ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0); |
|
| 1102 |
ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1); |
|
| 1008 | 1103 |
} |
| 1009 | 1104 |
} |
| 1010 | 1105 |
|
| ... | ... | |
| 1057 | 1152 |
void MPV_frame_end(MpegEncContext *s) |
| 1058 | 1153 |
{
|
| 1059 | 1154 |
int i; |
| 1060 |
/* draw edge for correct motion prediction if outside */
|
|
| 1155 |
/* redraw edges for the frame if decoding didn't complete */
|
|
| 1061 | 1156 |
//just to make sure that all data is rendered. |
| 1062 | 1157 |
if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
|
| 1063 | 1158 |
ff_xvmc_field_end(s); |
| ... | ... | |
| 1067 | 1162 |
&& s->current_picture.reference |
| 1068 | 1163 |
&& !s->intra_only |
| 1069 | 1164 |
&& !(s->flags&CODEC_FLAG_EMU_EDGE)) {
|
| 1070 |
s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); |
|
| 1071 |
s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); |
|
| 1072 |
s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); |
|
| 1165 |
int edges = EDGE_BOTTOM | EDGE_TOP, h = s->v_edge_pos; |
|
| 1166 |
|
|
| 1167 |
s->dsp.draw_edges(s->current_picture_ptr->data[0], s->linesize , s->h_edge_pos , h , EDGE_WIDTH , edges); |
|
| 1168 |
s->dsp.draw_edges(s->current_picture_ptr->data[1], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges); |
|
| 1169 |
s->dsp.draw_edges(s->current_picture_ptr->data[2], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges); |
|
| 1170 |
|
|
| 1073 | 1171 |
} |
| 1172 |
|
|
| 1074 | 1173 |
emms_c(); |
| 1075 | 1174 |
|
| 1076 | 1175 |
s->last_pict_type = s->pict_type; |
| ... | ... | |
| 1091 | 1190 |
|
| 1092 | 1191 |
if(s->encoding){
|
| 1093 | 1192 |
/* release non-reference frames */ |
| 1094 |
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
|
| 1193 |
for(i=0; i<s->picture_count; i++){
|
|
| 1095 | 1194 |
if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
|
| 1096 | 1195 |
free_frame_buffer(s, &s->picture[i]); |
| 1097 | 1196 |
} |
| ... | ... | |
| 1104 | 1203 |
memset(&s->current_picture, 0, sizeof(Picture)); |
| 1105 | 1204 |
#endif |
| 1106 | 1205 |
s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr; |
| 1206 |
|
|
| 1207 |
if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
|
|
| 1208 |
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0); |
|
| 1209 |
} |
|
| 1107 | 1210 |
} |
| 1108 | 1211 |
|
| 1109 | 1212 |
/** |
| ... | ... | |
| 1768 | 1871 |
} |
| 1769 | 1872 |
} |
| 1770 | 1873 |
|
| 1874 |
/** |
|
| 1875 |
* find the lowest MB row referenced in the MVs |
|
| 1876 |
*/ |
|
| 1877 |
int MPV_lowest_referenced_row(MpegEncContext *s, int dir) |
|
| 1878 |
{
|
|
| 1879 |
int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample; |
|
| 1880 |
int my, off, i, mvs; |
|
| 1881 |
|
|
| 1882 |
if (s->picture_structure != PICT_FRAME) goto unhandled; |
|
| 1883 |
|
|
| 1884 |
switch (s->mv_type) {
|
|
| 1885 |
case MV_TYPE_16X16: |
|
| 1886 |
mvs = 1; |
|
| 1887 |
break; |
|
| 1888 |
case MV_TYPE_16X8: |
|
| 1889 |
mvs = 2; |
|
| 1890 |
break; |
|
| 1891 |
case MV_TYPE_8X8: |
|
| 1892 |
mvs = 4; |
|
| 1893 |
break; |
|
| 1894 |
default: |
|
| 1895 |
goto unhandled; |
|
| 1896 |
} |
|
| 1897 |
|
|
| 1898 |
for (i = 0; i < mvs; i++) {
|
|
| 1899 |
my = s->mv[dir][i][1]<<qpel_shift; |
|
| 1900 |
my_max = FFMAX(my_max, my); |
|
| 1901 |
my_min = FFMIN(my_min, my); |
|
| 1902 |
} |
|
| 1903 |
|
|
| 1904 |
off = (FFMAX(-my_min, my_max) + 63) >> 6; |
|
| 1905 |
|
|
| 1906 |
return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1); |
|
| 1907 |
unhandled: |
|
| 1908 |
return s->mb_height-1; |
|
| 1909 |
} |
|
| 1910 |
|
|
| 1771 | 1911 |
/* put block[] to dest[] */ |
| 1772 | 1912 |
static inline void put_dct(MpegEncContext *s, |
| 1773 | 1913 |
DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) |
| ... | ... | |
| 1932 | 2072 |
/* motion handling */ |
| 1933 | 2073 |
/* decoding or more than one mb_type (MC was already done otherwise) */ |
| 1934 | 2074 |
if(!s->encoding){
|
| 2075 |
|
|
| 2076 |
if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
|
|
| 2077 |
if (s->mv_dir & MV_DIR_FORWARD) {
|
|
| 2078 |
ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0); |
|
| 2079 |
} |
|
| 2080 |
if (s->mv_dir & MV_DIR_BACKWARD) {
|
|
| 2081 |
ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0); |
|
| 2082 |
} |
|
| 2083 |
} |
|
| 2084 |
|
|
| 1935 | 2085 |
if(lowres_flag){
|
| 1936 | 2086 |
h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab; |
| 1937 | 2087 |
|
| ... | ... | |
| 2096 | 2246 |
* @param h is the normal height, this will be reduced automatically if needed for the last row |
| 2097 | 2247 |
*/ |
| 2098 | 2248 |
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
|
| 2249 |
const int field_pic= s->picture_structure != PICT_FRAME; |
|
| 2250 |
if(field_pic){
|
|
| 2251 |
h <<= 1; |
|
| 2252 |
y <<= 1; |
|
| 2253 |
} |
|
| 2254 |
|
|
| 2255 |
if (!s->avctx->hwaccel |
|
| 2256 |
&& !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) |
|
| 2257 |
&& s->unrestricted_mv |
|
| 2258 |
&& s->current_picture.reference |
|
| 2259 |
&& !s->intra_only |
|
| 2260 |
&& !(s->flags&CODEC_FLAG_EMU_EDGE)) {
|
|
| 2261 |
int sides = 0, edge_h; |
|
| 2262 |
if (y==0) sides |= EDGE_TOP; |
|
| 2263 |
if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM; |
|
| 2264 |
|
|
| 2265 |
edge_h= FFMIN(h, s->v_edge_pos - y); |
|
| 2266 |
|
|
| 2267 |
s->dsp.draw_edges(s->current_picture_ptr->data[0] + y *s->linesize , s->linesize , s->h_edge_pos , edge_h , EDGE_WIDTH , sides); |
|
| 2268 |
s->dsp.draw_edges(s->current_picture_ptr->data[1] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides); |
|
| 2269 |
s->dsp.draw_edges(s->current_picture_ptr->data[2] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides); |
|
| 2270 |
} |
|
| 2271 |
|
|
| 2272 |
h= FFMIN(h, s->avctx->height - y); |
|
| 2273 |
|
|
| 2274 |
if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; |
|
| 2275 |
|
|
| 2099 | 2276 |
if (s->avctx->draw_horiz_band) {
|
| 2100 | 2277 |
AVFrame *src; |
| 2101 |
const int field_pic= s->picture_structure != PICT_FRAME; |
|
| 2102 | 2278 |
int offset[4]; |
| 2103 | 2279 |
|
| 2104 |
h= FFMIN(h, (s->avctx->height>>field_pic) - y); |
|
| 2105 |
|
|
| 2106 |
if(field_pic && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)){
|
|
| 2107 |
h <<= 1; |
|
| 2108 |
y <<= 1; |
|
| 2109 |
if(s->first_field) return; |
|
| 2110 |
} |
|
| 2111 |
|
|
| 2112 | 2280 |
if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) |
| 2113 | 2281 |
src= (AVFrame*)s->current_picture_ptr; |
| 2114 | 2282 |
else if(s->last_picture_ptr) |
| ... | ... | |
| 2174 | 2342 |
if(s==NULL || s->picture==NULL) |
| 2175 | 2343 |
return; |
| 2176 | 2344 |
|
| 2177 |
for(i=0; i<MAX_PICTURE_COUNT; i++){
|
|
| 2345 |
for(i=0; i<s->picture_count; i++){
|
|
| 2178 | 2346 |
if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL |
| 2179 | 2347 |
|| s->picture[i].type == FF_BUFFER_TYPE_USER)) |
| 2180 | 2348 |
free_frame_buffer(s, &s->picture[i]); |
| ... | ... | |
| 2428 | 2596 |
s->y_dc_scale= s->y_dc_scale_table[ qscale ]; |
| 2429 | 2597 |
s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ]; |
| 2430 | 2598 |
} |
| 2599 |
|
|
| 2600 |
void MPV_report_decode_progress(MpegEncContext *s) |
|
| 2601 |
{
|
|
| 2602 |
if (s->pict_type != FF_B_TYPE && !s->partitioned_frame) |
|
| 2603 |
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0); |
|
| 2604 |
} |
|
Also available in: Unified diff