2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/intmath.h"
31 #include "libavutil/imgutils.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
40 #include "xvmc_internal.h"
47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
58 DCTELEM *block, int n, int qscale);
59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
60 DCTELEM *block, int n, int qscale);
63 /* enable all paranoid tests for rounding, overflows, etc... */
69 static const uint8_t ff_default_chroma_qscale_table[32]={
70 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
71 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
74 const uint8_t ff_mpeg1_dc_scale_table[128]={
75 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
76 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 static const uint8_t mpeg2_dc_scale_table1[128]={
83 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
84 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 static const uint8_t mpeg2_dc_scale_table2[128]={
91 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
92 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
98 static const uint8_t mpeg2_dc_scale_table3[128]={
99 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
100 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
102 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
103 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
106 const uint8_t * const ff_mpeg2_dc_scale_table[4]={
107 ff_mpeg1_dc_scale_table,
108 mpeg2_dc_scale_table1,
109 mpeg2_dc_scale_table2,
110 mpeg2_dc_scale_table3,
113 const enum PixelFormat ff_pixfmt_list_420[] = {
118 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
125 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
133 uint32_t tmp= *state << 8;
134 *state= tmp + *(p++);
135 if(tmp == 0x100 || p==end)
140 if (p[-1] > 1 ) p+= 3;
141 else if(p[-2] ) p+= 2;
142 else if(p[-3]|(p[-1]-1)) p++;
155 /* init common dct for both encoder and decoder */
156 av_cold int ff_dct_common_init(MpegEncContext *s)
158 dsputil_init(&s->dsp, s->avctx);
160 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
161 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
162 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
163 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
164 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
165 if(s->flags & CODEC_FLAG_BITEXACT)
166 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
167 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
170 MPV_common_init_mmx(s);
172 MPV_common_init_axp(s);
174 MPV_common_init_mlib(s);
176 MPV_common_init_mmi(s);
178 MPV_common_init_arm(s);
180 MPV_common_init_altivec(s);
182 MPV_common_init_bfin(s);
185 /* load & permutate scantables
186 note: only wmv uses different ones
188 if(s->alternate_scan){
189 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
190 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
192 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
193 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
195 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
196 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
201 void ff_copy_picture(Picture *dst, Picture *src){
203 dst->f.type= FF_BUFFER_TYPE_COPY;
207 * Release a frame buffer
209 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
211 /* Windows Media Image codecs allocate internal buffers with different
212 dimensions; ignore user defined callbacks for these */
213 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
214 ff_thread_release_buffer(s->avctx, (AVFrame*)pic);
216 avcodec_default_release_buffer(s->avctx, (AVFrame*)pic);
217 av_freep(&pic->f.hwaccel_picture_private);
221 * Allocate a frame buffer
223 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
227 if (s->avctx->hwaccel) {
228 assert(!pic->f.hwaccel_picture_private);
229 if (s->avctx->hwaccel->priv_data_size) {
230 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
231 if (!pic->f.hwaccel_picture_private) {
232 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
238 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
239 r = ff_thread_get_buffer(s->avctx, (AVFrame*)pic);
241 r = avcodec_default_get_buffer(s->avctx, (AVFrame*)pic);
243 if (r < 0 || !pic->f.age || !pic->f.type || !pic->f.data[0]) {
244 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n",
245 r, pic->f.age, pic->f.type, pic->f.data[0]);
246 av_freep(&pic->f.hwaccel_picture_private);
250 if (s->linesize && (s->linesize != pic->f.linesize[0] || s->uvlinesize != pic->f.linesize[1])) {
251 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
252 free_frame_buffer(s, pic);
256 if (pic->f.linesize[1] != pic->f.linesize[2]) {
257 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
258 free_frame_buffer(s, pic);
266 * allocates a Picture
267 * The pixels are allocated/set by calling get_buffer() if shared=0
269 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
270 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
271 const int mb_array_size= s->mb_stride*s->mb_height;
272 const int b8_array_size= s->b8_stride*s->mb_height*2;
273 const int b4_array_size= s->b4_stride*s->mb_height*4;
278 assert(pic->f.data[0]);
279 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
280 pic->f.type = FF_BUFFER_TYPE_SHARED;
282 assert(!pic->f.data[0]);
284 if (alloc_frame_buffer(s, pic) < 0)
287 s->linesize = pic->f.linesize[0];
288 s->uvlinesize = pic->f.linesize[1];
291 if (pic->f.qscale_table == NULL) {
293 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var , mb_array_size * sizeof(int16_t) , fail)
294 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var, mb_array_size * sizeof(int16_t) , fail)
295 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean , mb_array_size * sizeof(int8_t ) , fail)
298 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table, mb_array_size * sizeof(uint8_t) + 2, fail) //the +2 is for the slice end check
299 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base , (big_mb_num + s->mb_stride) * sizeof(uint8_t) , fail)
300 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t), fail)
301 pic->f.mb_type = pic->mb_type_base + 2*s->mb_stride + 1;
302 pic->f.qscale_table = pic->qscale_table_base + 2*s->mb_stride + 1;
303 if(s->out_format == FMT_H264){
305 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t), fail)
306 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
307 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
309 pic->f.motion_subsample_log2 = 2;
310 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
312 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t), fail)
313 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
314 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
316 pic->f.motion_subsample_log2 = 3;
318 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
319 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff, 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
321 pic->f.qstride = s->mb_stride;
322 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan , 1 * sizeof(AVPanScan), fail)
325 /* It might be nicer if the application would keep track of these
326 * but it would require an API change. */
327 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
328 s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
329 if (pic->f.age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->f.age] == AV_PICTURE_TYPE_B)
330 pic->f.age = INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
334 fail: //for the FF_ALLOCZ_OR_GOTO macro
336 free_frame_buffer(s, pic);
341 * deallocates a picture
343 static void free_picture(MpegEncContext *s, Picture *pic){
346 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
347 free_frame_buffer(s, pic);
350 av_freep(&pic->mb_var);
351 av_freep(&pic->mc_mb_var);
352 av_freep(&pic->mb_mean);
353 av_freep(&pic->f.mbskip_table);
354 av_freep(&pic->qscale_table_base);
355 av_freep(&pic->mb_type_base);
356 av_freep(&pic->f.dct_coeff);
357 av_freep(&pic->f.pan_scan);
358 pic->f.mb_type = NULL;
360 av_freep(&pic->motion_val_base[i]);
361 av_freep(&pic->f.ref_index[i]);
364 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
367 pic->f.data[i] = NULL;
373 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
374 int y_size = s->b8_stride * (2 * s->mb_height + 1);
375 int c_size = s->mb_stride * (s->mb_height + 1);
376 int yc_size = y_size + 2 * c_size;
379 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
380 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, (s->width+64)*2*21*2, fail); //(width + edge + align)*interlaced*MBsize*tolerance
382 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
383 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t), fail)
384 s->me.temp= s->me.scratchpad;
385 s->rd_scratchpad= s->me.scratchpad;
386 s->b_scratchpad= s->me.scratchpad;
387 s->obmc_scratchpad= s->me.scratchpad + 16;
389 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map , ME_MAP_SIZE*sizeof(uint32_t), fail)
390 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t), fail)
391 if(s->avctx->noise_reduction){
392 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
395 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
396 s->block= s->blocks[0];
399 s->pblocks[i] = &s->block[i];
402 if (s->out_format == FMT_H263) {
404 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
405 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
406 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
407 s->ac_val[2] = s->ac_val[1] + c_size;
412 return -1; //free() through MPV_common_end()
415 static void free_duplicate_context(MpegEncContext *s){
418 av_freep(&s->edge_emu_buffer);
419 av_freep(&s->me.scratchpad);
423 s->obmc_scratchpad= NULL;
425 av_freep(&s->dct_error_sum);
426 av_freep(&s->me.map);
427 av_freep(&s->me.score_map);
428 av_freep(&s->blocks);
429 av_freep(&s->ac_val_base);
433 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
434 #define COPY(a) bak->a= src->a
435 COPY(edge_emu_buffer);
440 COPY(obmc_scratchpad);
447 COPY(me.map_generation);
459 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
462 //FIXME copy only needed parts
464 backup_duplicate_context(&bak, dst);
465 memcpy(dst, src, sizeof(MpegEncContext));
466 backup_duplicate_context(dst, &bak);
468 dst->pblocks[i] = &dst->block[i];
470 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
473 int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
475 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
477 if(dst == src || !s1->context_initialized) return 0;
479 //FIXME can parameters change on I-frames? in that case dst may need a reinit
480 if(!s->context_initialized){
481 memcpy(s, s1, sizeof(MpegEncContext));
484 s->picture_range_start += MAX_PICTURE_COUNT;
485 s->picture_range_end += MAX_PICTURE_COUNT;
486 s->bitstream_buffer = NULL;
487 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
492 s->avctx->coded_height = s1->avctx->coded_height;
493 s->avctx->coded_width = s1->avctx->coded_width;
494 s->avctx->width = s1->avctx->width;
495 s->avctx->height = s1->avctx->height;
497 s->coded_picture_number = s1->coded_picture_number;
498 s->picture_number = s1->picture_number;
499 s->input_picture_number = s1->input_picture_number;
501 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
502 memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture);
504 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
505 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
506 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
508 memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
510 //Error/bug resilience
511 s->next_p_frame_damaged = s1->next_p_frame_damaged;
512 s->workaround_bugs = s1->workaround_bugs;
515 memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits);
518 s->max_b_frames = s1->max_b_frames;
519 s->low_delay = s1->low_delay;
520 s->dropable = s1->dropable;
522 //DivX handling (doesn't work)
523 s->divx_packed = s1->divx_packed;
525 if(s1->bitstream_buffer){
526 if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
527 av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size);
528 s->bitstream_buffer_size = s1->bitstream_buffer_size;
529 memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size);
530 memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
533 //MPEG2/interlacing info
534 memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence);
536 if(!s1->first_field){
537 s->last_pict_type= s1->pict_type;
538 if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
540 if (s1->pict_type != AV_PICTURE_TYPE_B) {
541 s->last_non_b_pict_type= s1->pict_type;
549 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
550 * the changed fields will not depend upon the prior state of the MpegEncContext.
552 void MPV_common_defaults(MpegEncContext *s){
554 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
555 s->chroma_qscale_table= ff_default_chroma_qscale_table;
556 s->progressive_frame= 1;
557 s->progressive_sequence= 1;
558 s->picture_structure= PICT_FRAME;
560 s->coded_picture_number = 0;
561 s->picture_number = 0;
562 s->input_picture_number = 0;
564 s->picture_in_gop_number = 0;
569 s->picture_range_start = 0;
570 s->picture_range_end = MAX_PICTURE_COUNT;
574 * sets the given MpegEncContext to defaults for decoding.
575 * the changed fields will not depend upon the prior state of the MpegEncContext.
577 void MPV_decode_defaults(MpegEncContext *s){
578 MPV_common_defaults(s);
582 * init common structure for both encoder and decoder.
583 * this assumes that some variables like width/height are already set
585 av_cold int MPV_common_init(MpegEncContext *s)
587 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y,
588 threads = (s->encoding ||
590 s->avctx->active_thread_type & FF_THREAD_SLICE)) ?
591 s->avctx->thread_count : 1;
593 if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
594 s->mb_height = (s->height + 31) / 32 * 2;
595 else if (s->codec_id != CODEC_ID_H264)
596 s->mb_height = (s->height + 15) / 16;
598 if(s->avctx->pix_fmt == PIX_FMT_NONE){
599 av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
603 if((s->encoding || (s->avctx->active_thread_type & FF_THREAD_SLICE)) &&
604 (s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
605 int max_threads = FFMIN(MAX_THREADS, s->mb_height);
606 av_log(s->avctx, AV_LOG_WARNING, "too many threads (%d), reducing to %d\n",
607 s->avctx->thread_count, max_threads);
608 threads = max_threads;
611 if((s->width || s->height) && av_image_check_size(s->width, s->height, 0, s->avctx))
614 ff_dct_common_init(s);
616 s->flags= s->avctx->flags;
617 s->flags2= s->avctx->flags2;
619 s->mb_width = (s->width + 15) / 16;
620 s->mb_stride = s->mb_width + 1;
621 s->b8_stride = s->mb_width*2 + 1;
622 s->b4_stride = s->mb_width*4 + 1;
623 mb_array_size= s->mb_height * s->mb_stride;
624 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
626 /* set chroma shifts */
627 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
628 &(s->chroma_y_shift) );
630 /* set default edge pos, will be overriden in decode_header if needed */
631 s->h_edge_pos= s->mb_width*16;
632 s->v_edge_pos= s->mb_height*16;
634 s->mb_num = s->mb_width * s->mb_height;
639 s->block_wrap[3]= s->b8_stride;
641 s->block_wrap[5]= s->mb_stride;
643 y_size = s->b8_stride * (2 * s->mb_height + 1);
644 c_size = s->mb_stride * (s->mb_height + 1);
645 yc_size = y_size + 2 * c_size;
647 /* convert fourcc to upper case */
648 s->codec_tag = ff_toupper4(s->avctx->codec_tag);
650 s->stream_codec_tag = ff_toupper4(s->avctx->stream_codec_tag);
652 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
654 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
655 for(y=0; y<s->mb_height; y++){
656 for(x=0; x<s->mb_width; x++){
657 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
660 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
663 /* Allocate MV tables */
664 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
665 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
666 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
667 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
668 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
669 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
670 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
671 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
672 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
673 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
674 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
675 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
677 if(s->msmpeg4_version){
678 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
680 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
682 /* Allocate MB type table */
683 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
685 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
687 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
688 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix , 64*32 * sizeof(int), fail)
689 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
690 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
691 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
692 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
693 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
694 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
696 if(s->avctx->noise_reduction){
697 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
701 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
702 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
703 for(i = 0; i < s->picture_count; i++) {
704 avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
707 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
709 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
710 /* interlaced direct mode decoding tables */
715 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
716 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
718 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
719 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
720 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
722 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
725 if (s->out_format == FMT_H263) {
727 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
728 s->coded_block= s->coded_block_base + s->b8_stride + 1;
730 /* cbp, ac_pred, pred_dir */
731 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail)
732 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
735 if (s->h263_pred || s->h263_plus || !s->encoding) {
737 //MN: we need these for error resilience of intra-frames
738 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
739 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
740 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
741 s->dc_val[2] = s->dc_val[1] + c_size;
742 for(i=0;i<yc_size;i++)
743 s->dc_val_base[i] = 1024;
746 /* which mb is a intra block */
747 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
748 memset(s->mbintra_table, 1, mb_array_size);
750 /* init macroblock skip table */
751 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
752 //Note the +1 is for a quicker mpeg4 slice_end detection
753 FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
755 s->parse_context.state= -1;
756 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
757 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
758 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
759 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
762 s->context_initialized = 1;
763 s->thread_context[0]= s;
765 if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
766 for(i=1; i<threads; i++){
767 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
768 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
771 for(i=0; i<threads; i++){
772 if(init_duplicate_context(s->thread_context[i], s) < 0)
774 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
775 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
778 if(init_duplicate_context(s, s) < 0) goto fail;
780 s->end_mb_y = s->mb_height;
790 /* init common structure for both encoder and decoder */
791 void MPV_common_end(MpegEncContext *s)
795 if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
796 for(i=0; i<s->avctx->thread_count; i++){
797 free_duplicate_context(s->thread_context[i]);
799 for(i=1; i<s->avctx->thread_count; i++){
800 av_freep(&s->thread_context[i]);
802 } else free_duplicate_context(s);
804 av_freep(&s->parse_context.buffer);
805 s->parse_context.buffer_size=0;
807 av_freep(&s->mb_type);
808 av_freep(&s->p_mv_table_base);
809 av_freep(&s->b_forw_mv_table_base);
810 av_freep(&s->b_back_mv_table_base);
811 av_freep(&s->b_bidir_forw_mv_table_base);
812 av_freep(&s->b_bidir_back_mv_table_base);
813 av_freep(&s->b_direct_mv_table_base);
815 s->b_forw_mv_table= NULL;
816 s->b_back_mv_table= NULL;
817 s->b_bidir_forw_mv_table= NULL;
818 s->b_bidir_back_mv_table= NULL;
819 s->b_direct_mv_table= NULL;
823 av_freep(&s->b_field_mv_table_base[i][j][k]);
824 s->b_field_mv_table[i][j][k]=NULL;
826 av_freep(&s->b_field_select_table[i][j]);
827 av_freep(&s->p_field_mv_table_base[i][j]);
828 s->p_field_mv_table[i][j]=NULL;
830 av_freep(&s->p_field_select_table[i]);
833 av_freep(&s->dc_val_base);
834 av_freep(&s->coded_block_base);
835 av_freep(&s->mbintra_table);
836 av_freep(&s->cbp_table);
837 av_freep(&s->pred_dir_table);
839 av_freep(&s->mbskip_table);
840 av_freep(&s->prev_pict_types);
841 av_freep(&s->bitstream_buffer);
842 s->allocated_bitstream_buffer_size=0;
844 av_freep(&s->avctx->stats_out);
845 av_freep(&s->ac_stats);
846 av_freep(&s->error_status_table);
847 av_freep(&s->mb_index2xy);
848 av_freep(&s->lambda_table);
849 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
850 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
851 s->q_chroma_intra_matrix= NULL;
852 s->q_chroma_intra_matrix16= NULL;
853 av_freep(&s->q_intra_matrix);
854 av_freep(&s->q_inter_matrix);
855 av_freep(&s->q_intra_matrix16);
856 av_freep(&s->q_inter_matrix16);
857 av_freep(&s->input_picture);
858 av_freep(&s->reordered_input_picture);
859 av_freep(&s->dct_offset);
861 if(s->picture && !s->avctx->is_copy){
862 for(i=0; i<s->picture_count; i++){
863 free_picture(s, &s->picture[i]);
866 av_freep(&s->picture);
867 s->context_initialized = 0;
870 s->current_picture_ptr= NULL;
871 s->linesize= s->uvlinesize= 0;
874 av_freep(&s->visualization_buffer[i]);
876 if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
877 avcodec_default_free_buffers(s->avctx);
880 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
882 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
883 uint8_t index_run[MAX_RUN+1];
884 int last, run, level, start, end, i;
886 /* If table is static, we can quit if rl->max_level[0] is not NULL */
887 if(static_store && rl->max_level[0])
890 /* compute max_level[], max_run[] and index_run[] */
891 for(last=0;last<2;last++) {
900 memset(max_level, 0, MAX_RUN + 1);
901 memset(max_run, 0, MAX_LEVEL + 1);
902 memset(index_run, rl->n, MAX_RUN + 1);
903 for(i=start;i<end;i++) {
904 run = rl->table_run[i];
905 level = rl->table_level[i];
906 if (index_run[run] == rl->n)
908 if (level > max_level[run])
909 max_level[run] = level;
910 if (run > max_run[level])
911 max_run[level] = run;
914 rl->max_level[last] = static_store[last];
916 rl->max_level[last] = av_malloc(MAX_RUN + 1);
917 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
919 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
921 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
922 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
924 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
926 rl->index_run[last] = av_malloc(MAX_RUN + 1);
927 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
931 void init_vlc_rl(RLTable *rl)
943 for(i=0; i<rl->vlc.table_size; i++){
944 int code= rl->vlc.table[i][0];
945 int len = rl->vlc.table[i][1];
948 if(len==0){ // illegal code
951 }else if(len<0){ //more bits needed
955 if(code==rl->n){ //esc
959 run= rl->table_run [code] + 1;
960 level= rl->table_level[code] * qmul + qadd;
961 if(code >= rl->last) run+=192;
964 rl->rl_vlc[q][i].len= len;
965 rl->rl_vlc[q][i].level= level;
966 rl->rl_vlc[q][i].run= run;
971 void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
975 /* release non reference frames */
976 for(i=0; i<s->picture_count; i++){
977 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
978 && (!s->picture[i].owner2 || s->picture[i].owner2 == s)
979 && (remove_current || &s->picture[i] != s->current_picture_ptr)
980 /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
981 free_frame_buffer(s, &s->picture[i]);
986 int ff_find_unused_picture(MpegEncContext *s, int shared){
990 for(i=s->picture_range_start; i<s->picture_range_end; i++){
991 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
995 for(i=s->picture_range_start; i<s->picture_range_end; i++){
996 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
999 for(i=s->picture_range_start; i<s->picture_range_end; i++){
1000 if (s->picture[i].f.data[0] == NULL)
1005 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
1006 /* We could return -1, but the codec would crash trying to draw into a
1007 * non-existing frame anyway. This is safer than waiting for a random crash.
1008 * Also the return of this is never useful, an encoder must only allocate
1009 * as much as allowed in the specification. This has no relationship to how
1010 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1011 * enough for such valid streams).
1012 * Plus, a decoder has to check stream validity and remove frames if too
1013 * many reference frames are around. Waiting for "OOM" is not correct at
1014 * all. Similarly, missing reference frames have to be replaced by
1015 * interpolated/MC frames, anything else is a bug in the codec ...
1021 static void update_noise_reduction(MpegEncContext *s){
1024 for(intra=0; intra<2; intra++){
1025 if(s->dct_count[intra] > (1<<16)){
1026 for(i=0; i<64; i++){
1027 s->dct_error_sum[intra][i] >>=1;
1029 s->dct_count[intra] >>= 1;
1032 for(i=0; i<64; i++){
1033 s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1039 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1041 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1047 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1049 /* mark&release old frames */
1050 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->f.data[0]) {
1051 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1052 if (s->last_picture_ptr->owner2 == s)
1053 free_frame_buffer(s, s->last_picture_ptr);
1055 /* release forgotten pictures */
1056 /* if(mpeg124/h263) */
1058 for(i=0; i<s->picture_count; i++){
1059 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].f.reference) {
1060 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1061 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1062 free_frame_buffer(s, &s->picture[i]);
1070 ff_release_unused_pictures(s, 1);
1072 if (s->current_picture_ptr && s->current_picture_ptr->f.data[0] == NULL)
1073 pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1075 i= ff_find_unused_picture(s, 0);
1076 pic= &s->picture[i];
1079 pic->f.reference = 0;
1081 if (s->codec_id == CODEC_ID_H264)
1082 pic->f.reference = s->picture_structure;
1083 else if (s->pict_type != AV_PICTURE_TYPE_B)
1084 pic->f.reference = 3;
1087 pic->f.coded_picture_number = s->coded_picture_number++;
1089 if(ff_alloc_picture(s, pic, 0) < 0)
1092 s->current_picture_ptr= pic;
1093 //FIXME use only the vars from current_pic
1094 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1095 if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1096 if(s->picture_structure != PICT_FRAME)
1097 s->current_picture_ptr->f.top_field_first = (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1099 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame && !s->progressive_sequence;
1100 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1103 s->current_picture_ptr->f.pict_type = s->pict_type;
1104 // if(s->flags && CODEC_FLAG_QSCALE)
1105 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1106 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1108 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1110 if (s->pict_type != AV_PICTURE_TYPE_B) {
1111 s->last_picture_ptr= s->next_picture_ptr;
1113 s->next_picture_ptr= s->current_picture_ptr;
1115 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1116 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1117 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1118 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1119 s->pict_type, s->dropable);*/
1121 if(s->codec_id != CODEC_ID_H264){
1122 if ((s->last_picture_ptr == NULL || s->last_picture_ptr->f.data[0] == NULL) &&
1123 (s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1124 if (s->pict_type != AV_PICTURE_TYPE_I)
1125 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1126 else if (s->picture_structure != PICT_FRAME)
1127 av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1129 /* Allocate a dummy frame */
1130 i= ff_find_unused_picture(s, 0);
1131 s->last_picture_ptr= &s->picture[i];
1132 s->last_picture_ptr->f.key_frame = 0;
1133 if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1135 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1136 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1138 if ((s->next_picture_ptr == NULL || s->next_picture_ptr->f.data[0] == NULL) && s->pict_type == AV_PICTURE_TYPE_B) {
1139 /* Allocate a dummy frame */
1140 i= ff_find_unused_picture(s, 0);
1141 s->next_picture_ptr= &s->picture[i];
1142 s->next_picture_ptr->f.key_frame = 0;
1143 if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1145 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1146 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1150 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1151 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1153 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->f.data[0]));
1155 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1158 if(s->picture_structure == PICT_BOTTOM_FIELD){
1159 s->current_picture.f.data[i] += s->current_picture.f.linesize[i];
1161 s->current_picture.f.linesize[i] *= 2;
1162 s->last_picture.f.linesize[i] *= 2;
1163 s->next_picture.f.linesize[i] *= 2;
1167 s->error_recognition= avctx->error_recognition;
1169 /* set dequantizer, we can't do it during init as it might change for mpeg4
1170 and we can't do it in the header decode as init is not called for mpeg4 there yet */
1171 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1172 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1173 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1174 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1175 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1176 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1178 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1179 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1182 if(s->dct_error_sum){
1183 assert(s->avctx->noise_reduction && s->encoding);
1185 update_noise_reduction(s);
1188 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1189 return ff_xvmc_field_start(s, avctx);
1194 /* generic function for encode/decode called after a frame has been coded/decoded */
1195 void MPV_frame_end(MpegEncContext *s)
1198 /* redraw edges for the frame if decoding didn't complete */
1199 //just to make sure that all data is rendered.
1200 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1201 ff_xvmc_field_end(s);
1202 }else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND))
1203 && !s->avctx->hwaccel
1204 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1205 && s->unrestricted_mv
1206 && s->current_picture.f.reference
1208 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1209 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1210 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1211 s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1212 s->h_edge_pos , s->v_edge_pos,
1213 EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1214 s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1215 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1216 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1217 s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1218 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1219 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1224 s->last_pict_type = s->pict_type;
1225 s->last_lambda_for[s->pict_type] = s->current_picture_ptr->f.quality;
1226 if(s->pict_type!=AV_PICTURE_TYPE_B){
1227 s->last_non_b_pict_type= s->pict_type;
1230 /* copy back current_picture variables */
1231 for(i=0; i<MAX_PICTURE_COUNT; i++){
1232 if(s->picture[i].f.data[0] == s->current_picture.f.data[0]){
1233 s->picture[i]= s->current_picture;
1237 assert(i<MAX_PICTURE_COUNT);
1241 /* release non-reference frames */
1242 for(i=0; i<s->picture_count; i++){
1243 if (s->picture[i].f.data[0] && !s->picture[i].f.reference /*&& s->picture[i].type != FF_BUFFER_TYPE_SHARED*/) {
1244 free_frame_buffer(s, &s->picture[i]);
1248 // clear copies, to avoid confusion
1250 memset(&s->last_picture, 0, sizeof(Picture));
1251 memset(&s->next_picture, 0, sizeof(Picture));
1252 memset(&s->current_picture, 0, sizeof(Picture));
1254 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1256 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1257 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1262 * draws an line from (ex, ey) -> (sx, sy).
1263 * @param w width of the image
1264 * @param h height of the image
1265 * @param stride stride/linesize of the image
1266 * @param color color of the arrow
1268 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1271 sx= av_clip(sx, 0, w-1);
1272 sy= av_clip(sy, 0, h-1);
1273 ex= av_clip(ex, 0, w-1);
1274 ey= av_clip(ey, 0, h-1);
1276 buf[sy*stride + sx]+= color;
1278 if(FFABS(ex - sx) > FFABS(ey - sy)){
1280 FFSWAP(int, sx, ex);
1281 FFSWAP(int, sy, ey);
1283 buf+= sx + sy*stride;
1285 f= ((ey-sy)<<16)/ex;
1286 for(x= 0; x <= ex; x++){
1289 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1290 buf[(y+1)*stride + x]+= (color* fr )>>16;
1294 FFSWAP(int, sx, ex);
1295 FFSWAP(int, sy, ey);
1297 buf+= sx + sy*stride;
1299 if(ey) f= ((ex-sx)<<16)/ey;
1301 for(y= 0; y <= ey; y++){
1304 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1305 buf[y*stride + x+1]+= (color* fr )>>16;
1311 * draws an arrow from (ex, ey) -> (sx, sy).
1312 * @param w width of the image
1313 * @param h height of the image
1314 * @param stride stride/linesize of the image
1315 * @param color color of the arrow
1317 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1320 sx= av_clip(sx, -100, w+100);
1321 sy= av_clip(sy, -100, h+100);
1322 ex= av_clip(ex, -100, w+100);
1323 ey= av_clip(ey, -100, h+100);
1328 if(dx*dx + dy*dy > 3*3){
1331 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1333 //FIXME subpixel accuracy
1334 rx= ROUNDED_DIV(rx*3<<4, length);
1335 ry= ROUNDED_DIV(ry*3<<4, length);
1337 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1338 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1340 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1344 * prints debuging info for the given picture.
1346 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1348 if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1350 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1353 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1354 av_get_picture_type_char(pict->pict_type));
1355 for(y=0; y<s->mb_height; y++){
1356 for(x=0; x<s->mb_width; x++){
1357 if(s->avctx->debug&FF_DEBUG_SKIP){
1358 int count= s->mbskip_table[x + y*s->mb_stride];
1359 if(count>9) count=9;
1360 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1362 if(s->avctx->debug&FF_DEBUG_QP){
1363 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1365 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1366 int mb_type= pict->mb_type[x + y*s->mb_stride];
1367 //Type & MV direction
1369 av_log(s->avctx, AV_LOG_DEBUG, "P");
1370 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1371 av_log(s->avctx, AV_LOG_DEBUG, "A");
1372 else if(IS_INTRA4x4(mb_type))
1373 av_log(s->avctx, AV_LOG_DEBUG, "i");
1374 else if(IS_INTRA16x16(mb_type))
1375 av_log(s->avctx, AV_LOG_DEBUG, "I");
1376 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1377 av_log(s->avctx, AV_LOG_DEBUG, "d");
1378 else if(IS_DIRECT(mb_type))
1379 av_log(s->avctx, AV_LOG_DEBUG, "D");
1380 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1381 av_log(s->avctx, AV_LOG_DEBUG, "g");
1382 else if(IS_GMC(mb_type))
1383 av_log(s->avctx, AV_LOG_DEBUG, "G");
1384 else if(IS_SKIP(mb_type))
1385 av_log(s->avctx, AV_LOG_DEBUG, "S");
1386 else if(!USES_LIST(mb_type, 1))
1387 av_log(s->avctx, AV_LOG_DEBUG, ">");
1388 else if(!USES_LIST(mb_type, 0))
1389 av_log(s->avctx, AV_LOG_DEBUG, "<");
1391 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1392 av_log(s->avctx, AV_LOG_DEBUG, "X");
1397 av_log(s->avctx, AV_LOG_DEBUG, "+");
1398 else if(IS_16X8(mb_type))
1399 av_log(s->avctx, AV_LOG_DEBUG, "-");
1400 else if(IS_8X16(mb_type))
1401 av_log(s->avctx, AV_LOG_DEBUG, "|");
1402 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1403 av_log(s->avctx, AV_LOG_DEBUG, " ");
1405 av_log(s->avctx, AV_LOG_DEBUG, "?");
1408 if(IS_INTERLACED(mb_type))
1409 av_log(s->avctx, AV_LOG_DEBUG, "=");
1411 av_log(s->avctx, AV_LOG_DEBUG, " ");
1413 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1415 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1419 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1420 const int shift= 1 + s->quarter_sample;
1424 int h_chroma_shift, v_chroma_shift, block_height;
1425 const int width = s->avctx->width;
1426 const int height= s->avctx->height;
1427 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1428 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1429 s->low_delay=0; //needed to see the vectors without trashing the buffers
1431 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1433 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1434 pict->data[i]= s->visualization_buffer[i];
1436 pict->type= FF_BUFFER_TYPE_COPY;
1439 block_height = 16>>v_chroma_shift;
1441 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1443 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1444 const int mb_index= mb_x + mb_y*s->mb_stride;
1445 if((s->avctx->debug_mv) && pict->motion_val){
1447 for(type=0; type<3; type++){
1450 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1454 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1458 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1463 if(!USES_LIST(pict->mb_type[mb_index], direction))
1466 if(IS_8X8(pict->mb_type[mb_index])){
1469 int sx= mb_x*16 + 4 + 8*(i&1);
1470 int sy= mb_y*16 + 4 + 8*(i>>1);
1471 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1472 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1473 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1474 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1476 }else if(IS_16X8(pict->mb_type[mb_index])){
1480 int sy=mb_y*16 + 4 + 8*i;
1481 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1482 int mx=(pict->motion_val[direction][xy][0]>>shift);
1483 int my=(pict->motion_val[direction][xy][1]>>shift);
1485 if(IS_INTERLACED(pict->mb_type[mb_index]))
1488 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1490 }else if(IS_8X16(pict->mb_type[mb_index])){
1493 int sx=mb_x*16 + 4 + 8*i;
1495 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1496 int mx=(pict->motion_val[direction][xy][0]>>shift);
1497 int my=(pict->motion_val[direction][xy][1]>>shift);
1499 if(IS_INTERLACED(pict->mb_type[mb_index]))
1502 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1505 int sx= mb_x*16 + 8;
1506 int sy= mb_y*16 + 8;
1507 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1508 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1509 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1510 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1514 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1515 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1517 for(y=0; y<block_height; y++){
1518 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1519 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1522 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1523 int mb_type= pict->mb_type[mb_index];
1526 #define COLOR(theta, r)\
1527 u= (int)(128 + r*cos(theta*3.141592/180));\
1528 v= (int)(128 + r*sin(theta*3.141592/180));
1532 if(IS_PCM(mb_type)){
1534 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1536 }else if(IS_INTRA4x4(mb_type)){
1538 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1540 }else if(IS_DIRECT(mb_type)){
1542 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1544 }else if(IS_GMC(mb_type)){
1546 }else if(IS_SKIP(mb_type)){
1548 }else if(!USES_LIST(mb_type, 1)){
1550 }else if(!USES_LIST(mb_type, 0)){
1553 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1557 u*= 0x0101010101010101ULL;
1558 v*= 0x0101010101010101ULL;
1559 for(y=0; y<block_height; y++){
1560 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1561 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1565 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1566 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1567 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1569 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1571 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1573 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1574 int dm= 1 << (mv_sample_log2-2);
1576 int sx= mb_x*16 + 8*(i&1);
1577 int sy= mb_y*16 + 8*(i>>1);
1578 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1580 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1581 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1583 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1584 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1585 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1589 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1593 s->mbskip_table[mb_index]=0;
1599 static inline int hpel_motion_lowres(MpegEncContext *s,
1600 uint8_t *dest, uint8_t *src,
1601 int field_based, int field_select,
1602 int src_x, int src_y,
1603 int width, int height, int stride,
1604 int h_edge_pos, int v_edge_pos,
1605 int w, int h, h264_chroma_mc_func *pix_op,
1606 int motion_x, int motion_y)
1608 const int lowres= s->avctx->lowres;
1609 const int op_index= FFMIN(lowres, 2);
1610 const int s_mask= (2<<lowres)-1;
1614 if(s->quarter_sample){
1619 sx= motion_x & s_mask;
1620 sy= motion_y & s_mask;
1621 src_x += motion_x >> (lowres+1);
1622 src_y += motion_y >> (lowres+1);
1624 src += src_y * stride + src_x;
1626 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1627 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1628 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1629 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1630 src= s->edge_emu_buffer;
1634 sx= (sx << 2) >> lowres;
1635 sy= (sy << 2) >> lowres;
1638 pix_op[op_index](dest, src, stride, h, sx, sy);
1642 /* apply one mpeg motion vector to the three components */
1643 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1644 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1645 int field_based, int bottom_field, int field_select,
1646 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1647 int motion_x, int motion_y, int h, int mb_y)
1649 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1650 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1651 const int lowres= s->avctx->lowres;
1652 const int op_index= FFMIN(lowres-1+s->chroma_x_shift, 2);
1653 const int block_s= 8>>lowres;
1654 const int s_mask= (2<<lowres)-1;
1655 const int h_edge_pos = s->h_edge_pos >> lowres;
1656 const int v_edge_pos = s->v_edge_pos >> lowres;
1657 linesize = s->current_picture.f.linesize[0] << field_based;
1658 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1660 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1666 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1669 sx= motion_x & s_mask;
1670 sy= motion_y & s_mask;
1671 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1672 src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1674 if (s->out_format == FMT_H263) {
1675 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1676 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1679 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1682 uvsx = (2*mx) & s_mask;
1683 uvsy = (2*my) & s_mask;
1684 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1685 uvsrc_y = mb_y*block_s + (my >> lowres);
1687 if(s->chroma_y_shift){
1692 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1693 uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
1695 if(s->chroma_x_shift){
1699 uvsy = motion_y & s_mask;
1701 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1704 uvsx = motion_x & s_mask;
1705 uvsy = motion_y & s_mask;
1712 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1713 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1714 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1716 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1717 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1718 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1719 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1720 ptr_y = s->edge_emu_buffer;
1721 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1722 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1723 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1724 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1725 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1726 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1732 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1733 dest_y += s->linesize;
1734 dest_cb+= s->uvlinesize;
1735 dest_cr+= s->uvlinesize;
1739 ptr_y += s->linesize;
1740 ptr_cb+= s->uvlinesize;
1741 ptr_cr+= s->uvlinesize;
1744 sx= (sx << 2) >> lowres;
1745 sy= (sy << 2) >> lowres;
1746 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1748 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1749 uvsx= (uvsx << 2) >> lowres;
1750 uvsy= (uvsy << 2) >> lowres;
1751 if(h >> s->chroma_y_shift){
1752 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1753 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1756 //FIXME h261 lowres loop filter
1759 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1760 uint8_t *dest_cb, uint8_t *dest_cr,
1761 uint8_t **ref_picture,
1762 h264_chroma_mc_func *pix_op,
1764 const int lowres= s->avctx->lowres;
1765 const int op_index= FFMIN(lowres, 2);
1766 const int block_s= 8>>lowres;
1767 const int s_mask= (2<<lowres)-1;
1768 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1769 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1770 int emu=0, src_x, src_y, offset, sx, sy;
1773 if(s->quarter_sample){
1778 /* In case of 8X8, we construct a single chroma motion vector
1779 with a special rounding */
1780 mx= ff_h263_round_chroma(mx);
1781 my= ff_h263_round_chroma(my);
1785 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1786 src_y = s->mb_y*block_s + (my >> (lowres+1));
1788 offset = src_y * s->uvlinesize + src_x;
1789 ptr = ref_picture[1] + offset;
1790 if(s->flags&CODEC_FLAG_EMU_EDGE){
1791 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1792 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1793 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1794 ptr= s->edge_emu_buffer;
1798 sx= (sx << 2) >> lowres;
1799 sy= (sy << 2) >> lowres;
1800 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1802 ptr = ref_picture[2] + offset;
1804 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1805 ptr= s->edge_emu_buffer;
1807 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1811 * motion compensation of a single macroblock
1813 * @param dest_y luma destination pointer
1814 * @param dest_cb chroma cb/u destination pointer
1815 * @param dest_cr chroma cr/v destination pointer
1816 * @param dir direction (0->forward, 1->backward)
1817 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1818 * @param pix_op halfpel motion compensation function (average or put normally)
1819 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1821 static inline void MPV_motion_lowres(MpegEncContext *s,
1822 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1823 int dir, uint8_t **ref_picture,
1824 h264_chroma_mc_func *pix_op)
1828 const int lowres= s->avctx->lowres;
1829 const int block_s= 8>>lowres;
1834 switch(s->mv_type) {
1836 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1838 ref_picture, pix_op,
1839 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1845 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1846 ref_picture[0], 0, 0,
1847 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1848 s->width, s->height, s->linesize,
1849 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1850 block_s, block_s, pix_op,
1851 s->mv[dir][i][0], s->mv[dir][i][1]);
1853 mx += s->mv[dir][i][0];
1854 my += s->mv[dir][i][1];
1857 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1858 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1861 if (s->picture_structure == PICT_FRAME) {
1863 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1864 1, 0, s->field_select[dir][0],
1865 ref_picture, pix_op,
1866 s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1868 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1869 1, 1, s->field_select[dir][1],
1870 ref_picture, pix_op,
1871 s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1873 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1874 ref_picture = s->current_picture_ptr->f.data;
1877 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1878 0, 0, s->field_select[dir][0],
1879 ref_picture, pix_op,
1880 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1885 uint8_t ** ref2picture;
1887 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1888 ref2picture= ref_picture;
1890 ref2picture = s->current_picture_ptr->f.data;
1893 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1894 0, 0, s->field_select[dir][i],
1895 ref2picture, pix_op,
1896 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1898 dest_y += 2*block_s*s->linesize;
1899 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1900 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1904 if(s->picture_structure == PICT_FRAME){
1908 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1910 ref_picture, pix_op,
1911 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1913 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1917 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1918 0, 0, s->picture_structure != i+1,
1919 ref_picture, pix_op,
1920 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1922 // after put we make avg of the same block
1923 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1925 //opposite parity is always in the same frame if this is second field
1926 if(!s->first_field){
1927 ref_picture = s->current_picture_ptr->f.data;
1937 * find the lowest MB row referenced in the MVs
1939 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1941 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1942 int my, off, i, mvs;
1944 if (s->picture_structure != PICT_FRAME) goto unhandled;
1946 switch (s->mv_type) {
1960 for (i = 0; i < mvs; i++) {
1961 my = s->mv[dir][i][1]<<qpel_shift;
1962 my_max = FFMAX(my_max, my);
1963 my_min = FFMIN(my_min, my);
1966 off = (FFMAX(-my_min, my_max) + 63) >> 6;
1968 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1970 return s->mb_height-1;
1973 /* put block[] to dest[] */
1974 static inline void put_dct(MpegEncContext *s,
1975 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1977 s->dct_unquantize_intra(s, block, i, qscale);
1978 s->dsp.idct_put (dest, line_size, block);
1981 /* add block[] to dest[] */
1982 static inline void add_dct(MpegEncContext *s,
1983 DCTELEM *block, int i, uint8_t *dest, int line_size)
1985 if (s->block_last_index[i] >= 0) {
1986 s->dsp.idct_add (dest, line_size, block);
1990 static inline void add_dequant_dct(MpegEncContext *s,
1991 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1993 if (s->block_last_index[i] >= 0) {
1994 s->dct_unquantize_inter(s, block, i, qscale);
1996 s->dsp.idct_add (dest, line_size, block);
2001 * cleans dc, ac, coded_block for the current non intra MB
2003 void ff_clean_intra_table_entries(MpegEncContext *s)
2005 int wrap = s->b8_stride;
2006 int xy = s->block_index[0];
2009 s->dc_val[0][xy + 1 ] =
2010 s->dc_val[0][xy + wrap] =
2011 s->dc_val[0][xy + 1 + wrap] = 1024;
2013 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2014 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2015 if (s->msmpeg4_version>=3) {
2016 s->coded_block[xy ] =
2017 s->coded_block[xy + 1 ] =
2018 s->coded_block[xy + wrap] =
2019 s->coded_block[xy + 1 + wrap] = 0;
2022 wrap = s->mb_stride;
2023 xy = s->mb_x + s->mb_y * wrap;
2025 s->dc_val[2][xy] = 1024;
2027 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2028 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2030 s->mbintra_table[xy]= 0;
2033 /* generic function called after a macroblock has been parsed by the
2034 decoder or after it has been encoded by the encoder.
2036 Important variables used:
2037 s->mb_intra : true if intra macroblock
2038 s->mv_dir : motion vector direction
2039 s->mv_type : motion vector type
2040 s->mv : motion vector
2041 s->interlaced_dct : true if interlaced dct used (mpeg2)
2043 static av_always_inline
2044 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2045 int lowres_flag, int is_mpeg12)
2047 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2048 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2049 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2053 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2054 /* save DCT coefficients */
2056 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2057 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2059 for(j=0; j<64; j++){
2060 *dct++ = block[i][s->dsp.idct_permutation[j]];
2061 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2063 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2067 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2069 /* update DC predictors for P macroblocks */
2071 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2072 if(s->mbintra_table[mb_xy])
2073 ff_clean_intra_table_entries(s);
2077 s->last_dc[2] = 128 << s->intra_dc_precision;
2080 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2081 s->mbintra_table[mb_xy]=1;
2083 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2084 uint8_t *dest_y, *dest_cb, *dest_cr;
2085 int dct_linesize, dct_offset;
2086 op_pixels_func (*op_pix)[4];
2087 qpel_mc_func (*op_qpix)[16];
2088 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2089 const int uvlinesize = s->current_picture.f.linesize[1];
2090 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2091 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2093 /* avoid copy if macroblock skipped in last frame too */
2094 /* skip only during decoding as we might trash the buffers during encoding a bit */
2096 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2097 const int age = s->current_picture.f.age;
2101 if (s->mb_skipped) {
2103 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2105 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2106 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2108 /* if previous was skipped too, then nothing to do ! */
2109 if (*mbskip_ptr >= age && s->current_picture.f.reference){
2112 } else if(!s->current_picture.f.reference) {
2113 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2114 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2116 *mbskip_ptr = 0; /* not skipped */
2120 dct_linesize = linesize << s->interlaced_dct;
2121 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2125 dest_cb= s->dest[1];
2126 dest_cr= s->dest[2];
2128 dest_y = s->b_scratchpad;
2129 dest_cb= s->b_scratchpad+16*linesize;
2130 dest_cr= s->b_scratchpad+32*linesize;
2134 /* motion handling */
2135 /* decoding or more than one mb_type (MC was already done otherwise) */
2138 if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2139 if (s->mv_dir & MV_DIR_FORWARD) {
2140 ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2142 if (s->mv_dir & MV_DIR_BACKWARD) {
2143 ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2148 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2150 if (s->mv_dir & MV_DIR_FORWARD) {
2151 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2152 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2154 if (s->mv_dir & MV_DIR_BACKWARD) {
2155 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2158 op_qpix= s->me.qpel_put;
2159 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2160 op_pix = s->dsp.put_pixels_tab;
2162 op_pix = s->dsp.put_no_rnd_pixels_tab;
2164 if (s->mv_dir & MV_DIR_FORWARD) {
2165 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2166 op_pix = s->dsp.avg_pixels_tab;
2167 op_qpix= s->me.qpel_avg;
2169 if (s->mv_dir & MV_DIR_BACKWARD) {
2170 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2175 /* skip dequant / idct if we are really late ;) */
2176 if(s->avctx->skip_idct){
2177 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2178 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2179 || s->avctx->skip_idct >= AVDISCARD_ALL)
2183 /* add dct residue */
2184 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2185 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2186 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2187 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2188 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2189 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2191 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2192 if (s->chroma_y_shift){
2193 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2194 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2198 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2199 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2200 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2201 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2204 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2205 add_dct(s, block[0], 0, dest_y , dct_linesize);
2206 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2207 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2208 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2210 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2211 if(s->chroma_y_shift){//Chroma420
2212 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2213 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2216 dct_linesize = uvlinesize << s->interlaced_dct;
2217 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2219 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2220 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2221 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2222 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2223 if(!s->chroma_x_shift){//Chroma444
2224 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2225 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2226 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2227 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2232 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2233 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2236 /* dct only in intra block */
2237 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2238 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2239 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2240 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2241 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2243 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2244 if(s->chroma_y_shift){
2245 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2246 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2250 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2251 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2252 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2253 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2257 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2258 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2259 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2260 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2262 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2263 if(s->chroma_y_shift){
2264 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2265 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2268 dct_linesize = uvlinesize << s->interlaced_dct;
2269 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2271 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2272 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2273 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2274 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2275 if(!s->chroma_x_shift){//Chroma444
2276 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2277 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2278 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2279 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2287 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2288 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2289 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2294 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2296 if(s->out_format == FMT_MPEG1) {
2297 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2298 else MPV_decode_mb_internal(s, block, 0, 1);
2301 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2302 else MPV_decode_mb_internal(s, block, 0, 0);
2307 * @param h is the normal height, this will be reduced automatically if needed for the last row
2309 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2310 const int field_pic= s->picture_structure != PICT_FRAME;
2316 if (!s->avctx->hwaccel
2317 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2318 && s->unrestricted_mv
2319 && s->current_picture.f.reference
2321 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2322 int sides = 0, edge_h;
2323 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2324 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2325 if (y==0) sides |= EDGE_TOP;
2326 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2328 edge_h= FFMIN(h, s->v_edge_pos - y);
2330 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2331 s->linesize, s->h_edge_pos, edge_h,
2332 EDGE_WIDTH, EDGE_WIDTH, sides);
2333 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2334 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2335 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2336 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2337 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2338 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2341 h= FFMIN(h, s->avctx->height - y);
2343 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2345 if (s->avctx->draw_horiz_band) {
2349 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2350 src= (AVFrame*)s->current_picture_ptr;
2351 else if(s->last_picture_ptr)
2352 src= (AVFrame*)s->last_picture_ptr;
2356 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2362 offset[0]= y * s->linesize;
2364 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2370 s->avctx->draw_horiz_band(s->avctx, src, offset,
2371 y, s->picture_structure, h);
2375 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2376 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2377 const int uvlinesize = s->current_picture.f.linesize[1];
2378 const int mb_size= 4 - s->avctx->lowres;
2380 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2381 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2382 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2383 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2384 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2385 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2386 //block_index is not used by mpeg2, so it is not affected by chroma_format
2388 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2389 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2390 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2392 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2394 if(s->picture_structure==PICT_FRAME){
2395 s->dest[0] += s->mb_y * linesize << mb_size;
2396 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2397 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2399 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2400 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2401 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2402 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2407 void ff_mpeg_flush(AVCodecContext *avctx){
2409 MpegEncContext *s = avctx->priv_data;
2411 if(s==NULL || s->picture==NULL)
2414 for(i=0; i<s->picture_count; i++){
2415 if (s->picture[i].f.data[0] &&
2416 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2417 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2418 free_frame_buffer(s, &s->picture[i]);
2420 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2422 s->mb_x= s->mb_y= 0;
2425 s->parse_context.state= -1;
2426 s->parse_context.frame_start_found= 0;
2427 s->parse_context.overread= 0;
2428 s->parse_context.overread_index= 0;
2429 s->parse_context.index= 0;
2430 s->parse_context.last_index= 0;
2431 s->bitstream_buffer_size=0;
2435 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2436 DCTELEM *block, int n, int qscale)
2438 int i, level, nCoeffs;
2439 const uint16_t *quant_matrix;
2441 nCoeffs= s->block_last_index[n];
2444 block[0] = block[0] * s->y_dc_scale;
2446 block[0] = block[0] * s->c_dc_scale;
2447 /* XXX: only mpeg1 */
2448 quant_matrix = s->intra_matrix;
2449 for(i=1;i<=nCoeffs;i++) {
2450 int j= s->intra_scantable.permutated[i];
2455 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2456 level = (level - 1) | 1;
2459 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2460 level = (level - 1) | 1;
2467 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2468 DCTELEM *block, int n, int qscale)
2470 int i, level, nCoeffs;
2471 const uint16_t *quant_matrix;
2473 nCoeffs= s->block_last_index[n];
2475 quant_matrix = s->inter_matrix;
2476 for(i=0; i<=nCoeffs; i++) {
2477 int j= s->intra_scantable.permutated[i];
2482 level = (((level << 1) + 1) * qscale *
2483 ((int) (quant_matrix[j]))) >> 4;
2484 level = (level - 1) | 1;
2487 level = (((level << 1) + 1) * qscale *
2488 ((int) (quant_matrix[j]))) >> 4;
2489 level = (level - 1) | 1;
2496 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2497 DCTELEM *block, int n, int qscale)
2499 int i, level, nCoeffs;
2500 const uint16_t *quant_matrix;
2502 if(s->alternate_scan) nCoeffs= 63;
2503 else nCoeffs= s->block_last_index[n];
2506 block[0] = block[0] * s->y_dc_scale;
2508 block[0] = block[0] * s->c_dc_scale;
2509 quant_matrix = s->intra_matrix;
2510 for(i=1;i<=nCoeffs;i++) {
2511 int j= s->intra_scantable.permutated[i];
2516 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2519 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2526 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2527 DCTELEM *block, int n, int qscale)
2529 int i, level, nCoeffs;
2530 const uint16_t *quant_matrix;
2533 if(s->alternate_scan) nCoeffs= 63;
2534 else nCoeffs= s->block_last_index[n];
2537 block[0] = block[0] * s->y_dc_scale;
2539 block[0] = block[0] * s->c_dc_scale;
2540 quant_matrix = s->intra_matrix;
2541 for(i=1;i<=nCoeffs;i++) {
2542 int j= s->intra_scantable.permutated[i];
2547 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2550 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2559 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2560 DCTELEM *block, int n, int qscale)
2562 int i, level, nCoeffs;
2563 const uint16_t *quant_matrix;
2566 if(s->alternate_scan) nCoeffs= 63;
2567 else nCoeffs= s->block_last_index[n];
2569 quant_matrix = s->inter_matrix;
2570 for(i=0; i<=nCoeffs; i++) {
2571 int j= s->intra_scantable.permutated[i];
2576 level = (((level << 1) + 1) * qscale *
2577 ((int) (quant_matrix[j]))) >> 4;
2580 level = (((level << 1) + 1) * qscale *
2581 ((int) (quant_matrix[j]))) >> 4;
2590 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2591 DCTELEM *block, int n, int qscale)
2593 int i, level, qmul, qadd;
2596 assert(s->block_last_index[n]>=0);
2602 block[0] = block[0] * s->y_dc_scale;
2604 block[0] = block[0] * s->c_dc_scale;
2605 qadd = (qscale - 1) | 1;
2612 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2614 for(i=1; i<=nCoeffs; i++) {
2618 level = level * qmul - qadd;
2620 level = level * qmul + qadd;
2627 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2628 DCTELEM *block, int n, int qscale)
2630 int i, level, qmul, qadd;
2633 assert(s->block_last_index[n]>=0);
2635 qadd = (qscale - 1) | 1;
2638 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2640 for(i=0; i<=nCoeffs; i++) {
2644 level = level * qmul - qadd;
2646 level = level * qmul + qadd;
2654 * set qscale and update qscale dependent variables.
2656 void ff_set_qscale(MpegEncContext * s, int qscale)
2660 else if (qscale > 31)
2664 s->chroma_qscale= s->chroma_qscale_table[qscale];
2666 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2667 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2670 void MPV_report_decode_progress(MpegEncContext *s)
2672 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2673 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);