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->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->type == 0 || pic->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->allocated_edge_emu_buffer, (s->width+64)*2*21*2, fail); //(width + edge + align)*interlaced*MBsize*tolerance
381 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
383 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
384 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t), fail)
385 s->me.temp= s->me.scratchpad;
386 s->rd_scratchpad= s->me.scratchpad;
387 s->b_scratchpad= s->me.scratchpad;
388 s->obmc_scratchpad= s->me.scratchpad + 16;
390 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map , ME_MAP_SIZE*sizeof(uint32_t), fail)
391 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t), fail)
392 if(s->avctx->noise_reduction){
393 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
396 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
397 s->block= s->blocks[0];
400 s->pblocks[i] = &s->block[i];
403 if (s->out_format == FMT_H263) {
405 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
406 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
407 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
408 s->ac_val[2] = s->ac_val[1] + c_size;
413 return -1; //free() through MPV_common_end()
416 static void free_duplicate_context(MpegEncContext *s){
419 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
420 av_freep(&s->me.scratchpad);
424 s->obmc_scratchpad= NULL;
426 av_freep(&s->dct_error_sum);
427 av_freep(&s->me.map);
428 av_freep(&s->me.score_map);
429 av_freep(&s->blocks);
430 av_freep(&s->ac_val_base);
434 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
435 #define COPY(a) bak->a= src->a
436 COPY(allocated_edge_emu_buffer);
437 COPY(edge_emu_buffer);
442 COPY(obmc_scratchpad);
449 COPY(me.map_generation);
461 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
464 //FIXME copy only needed parts
466 backup_duplicate_context(&bak, dst);
467 memcpy(dst, src, sizeof(MpegEncContext));
468 backup_duplicate_context(dst, &bak);
470 dst->pblocks[i] = &dst->block[i];
472 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
475 int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
477 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
479 if(dst == src || !s1->context_initialized) return 0;
481 //FIXME can parameters change on I-frames? in that case dst may need a reinit
482 if(!s->context_initialized){
483 memcpy(s, s1, sizeof(MpegEncContext));
486 s->picture_range_start += MAX_PICTURE_COUNT;
487 s->picture_range_end += MAX_PICTURE_COUNT;
488 s->bitstream_buffer = NULL;
489 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
494 s->avctx->coded_height = s1->avctx->coded_height;
495 s->avctx->coded_width = s1->avctx->coded_width;
496 s->avctx->width = s1->avctx->width;
497 s->avctx->height = s1->avctx->height;
499 s->coded_picture_number = s1->coded_picture_number;
500 s->picture_number = s1->picture_number;
501 s->input_picture_number = s1->input_picture_number;
503 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
504 memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture);
506 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
507 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
508 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
510 memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
512 //Error/bug resilience
513 s->next_p_frame_damaged = s1->next_p_frame_damaged;
514 s->workaround_bugs = s1->workaround_bugs;
517 memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits);
520 s->max_b_frames = s1->max_b_frames;
521 s->low_delay = s1->low_delay;
522 s->dropable = s1->dropable;
524 //DivX handling (doesn't work)
525 s->divx_packed = s1->divx_packed;
527 if(s1->bitstream_buffer){
528 if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
529 av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size);
530 s->bitstream_buffer_size = s1->bitstream_buffer_size;
531 memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size);
532 memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
535 //MPEG2/interlacing info
536 memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence);
538 if(!s1->first_field){
539 s->last_pict_type= s1->pict_type;
540 if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
542 if(s1->pict_type!=FF_B_TYPE){
543 s->last_non_b_pict_type= s1->pict_type;
551 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
552 * the changed fields will not depend upon the prior state of the MpegEncContext.
554 void MPV_common_defaults(MpegEncContext *s){
556 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
557 s->chroma_qscale_table= ff_default_chroma_qscale_table;
558 s->progressive_frame= 1;
559 s->progressive_sequence= 1;
560 s->picture_structure= PICT_FRAME;
562 s->coded_picture_number = 0;
563 s->picture_number = 0;
564 s->input_picture_number = 0;
566 s->picture_in_gop_number = 0;
571 s->picture_range_start = 0;
572 s->picture_range_end = MAX_PICTURE_COUNT;
576 * sets the given MpegEncContext to defaults for decoding.
577 * the changed fields will not depend upon the prior state of the MpegEncContext.
579 void MPV_decode_defaults(MpegEncContext *s){
580 MPV_common_defaults(s);
584 * init common structure for both encoder and decoder.
585 * this assumes that some variables like width/height are already set
587 av_cold int MPV_common_init(MpegEncContext *s)
589 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y,
590 threads = (s->encoding ||
592 s->avctx->active_thread_type & FF_THREAD_SLICE)) ?
593 s->avctx->thread_count : 1;
595 if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
596 s->mb_height = (s->height + 31) / 32 * 2;
597 else if (s->codec_id != CODEC_ID_H264)
598 s->mb_height = (s->height + 15) / 16;
600 if(s->avctx->pix_fmt == PIX_FMT_NONE){
601 av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
605 if((s->encoding || (s->avctx->active_thread_type & FF_THREAD_SLICE)) &&
606 (s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
607 int max_threads = FFMIN(MAX_THREADS, s->mb_height);
608 av_log(s->avctx, AV_LOG_WARNING, "too many threads (%d), reducing to %d\n",
609 s->avctx->thread_count, max_threads);
610 threads = max_threads;
613 if((s->width || s->height) && av_image_check_size(s->width, s->height, 0, s->avctx))
616 ff_dct_common_init(s);
618 s->flags= s->avctx->flags;
619 s->flags2= s->avctx->flags2;
621 s->mb_width = (s->width + 15) / 16;
622 s->mb_stride = s->mb_width + 1;
623 s->b8_stride = s->mb_width*2 + 1;
624 s->b4_stride = s->mb_width*4 + 1;
625 mb_array_size= s->mb_height * s->mb_stride;
626 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
628 /* set chroma shifts */
629 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
630 &(s->chroma_y_shift) );
632 /* set default edge pos, will be overriden in decode_header if needed */
633 s->h_edge_pos= s->mb_width*16;
634 s->v_edge_pos= s->mb_height*16;
636 s->mb_num = s->mb_width * s->mb_height;
641 s->block_wrap[3]= s->b8_stride;
643 s->block_wrap[5]= s->mb_stride;
645 y_size = s->b8_stride * (2 * s->mb_height + 1);
646 c_size = s->mb_stride * (s->mb_height + 1);
647 yc_size = y_size + 2 * c_size;
649 /* convert fourcc to upper case */
650 s->codec_tag = ff_toupper4(s->avctx->codec_tag);
652 s->stream_codec_tag = ff_toupper4(s->avctx->stream_codec_tag);
654 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
656 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
657 for(y=0; y<s->mb_height; y++){
658 for(x=0; x<s->mb_width; x++){
659 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
662 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
665 /* Allocate MV tables */
666 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
667 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
668 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
669 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
670 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
671 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
672 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
673 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
674 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
675 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
676 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
677 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
679 if(s->msmpeg4_version){
680 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
682 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
684 /* Allocate MB type table */
685 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
687 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
689 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
690 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
691 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_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 av_freep(&s->q_intra_matrix);
850 av_freep(&s->q_inter_matrix);
851 av_freep(&s->q_intra_matrix16);
852 av_freep(&s->q_inter_matrix16);
853 av_freep(&s->input_picture);
854 av_freep(&s->reordered_input_picture);
855 av_freep(&s->dct_offset);
857 if(s->picture && !s->avctx->is_copy){
858 for(i=0; i<s->picture_count; i++){
859 free_picture(s, &s->picture[i]);
862 av_freep(&s->picture);
863 s->context_initialized = 0;
866 s->current_picture_ptr= NULL;
867 s->linesize= s->uvlinesize= 0;
870 av_freep(&s->visualization_buffer[i]);
872 if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
873 avcodec_default_free_buffers(s->avctx);
876 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
878 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
879 uint8_t index_run[MAX_RUN+1];
880 int last, run, level, start, end, i;
882 /* If table is static, we can quit if rl->max_level[0] is not NULL */
883 if(static_store && rl->max_level[0])
886 /* compute max_level[], max_run[] and index_run[] */
887 for(last=0;last<2;last++) {
896 memset(max_level, 0, MAX_RUN + 1);
897 memset(max_run, 0, MAX_LEVEL + 1);
898 memset(index_run, rl->n, MAX_RUN + 1);
899 for(i=start;i<end;i++) {
900 run = rl->table_run[i];
901 level = rl->table_level[i];
902 if (index_run[run] == rl->n)
904 if (level > max_level[run])
905 max_level[run] = level;
906 if (run > max_run[level])
907 max_run[level] = run;
910 rl->max_level[last] = static_store[last];
912 rl->max_level[last] = av_malloc(MAX_RUN + 1);
913 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
915 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
917 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
918 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
920 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
922 rl->index_run[last] = av_malloc(MAX_RUN + 1);
923 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
927 void init_vlc_rl(RLTable *rl)
939 for(i=0; i<rl->vlc.table_size; i++){
940 int code= rl->vlc.table[i][0];
941 int len = rl->vlc.table[i][1];
944 if(len==0){ // illegal code
947 }else if(len<0){ //more bits needed
951 if(code==rl->n){ //esc
955 run= rl->table_run [code] + 1;
956 level= rl->table_level[code] * qmul + qadd;
957 if(code >= rl->last) run+=192;
960 rl->rl_vlc[q][i].len= len;
961 rl->rl_vlc[q][i].level= level;
962 rl->rl_vlc[q][i].run= run;
967 void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
971 /* release non reference frames */
972 for(i=0; i<s->picture_count; i++){
973 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
974 && (!s->picture[i].owner2 || s->picture[i].owner2 == s)
975 && (remove_current || &s->picture[i] != s->current_picture_ptr)
976 /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
977 free_frame_buffer(s, &s->picture[i]);
982 int ff_find_unused_picture(MpegEncContext *s, int shared){
986 for(i=s->picture_range_start; i<s->picture_range_end; i++){
987 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
991 for(i=s->picture_range_start; i<s->picture_range_end; i++){
992 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)
1001 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
1002 /* We could return -1, but the codec would crash trying to draw into a
1003 * non-existing frame anyway. This is safer than waiting for a random crash.
1004 * Also the return of this is never useful, an encoder must only allocate
1005 * as much as allowed in the specification. This has no relationship to how
1006 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1007 * enough for such valid streams).
1008 * Plus, a decoder has to check stream validity and remove frames if too
1009 * many reference frames are around. Waiting for "OOM" is not correct at
1010 * all. Similarly, missing reference frames have to be replaced by
1011 * interpolated/MC frames, anything else is a bug in the codec ...
1017 static void update_noise_reduction(MpegEncContext *s){
1020 for(intra=0; intra<2; intra++){
1021 if(s->dct_count[intra] > (1<<16)){
1022 for(i=0; i<64; i++){
1023 s->dct_error_sum[intra][i] >>=1;
1025 s->dct_count[intra] >>= 1;
1028 for(i=0; i<64; i++){
1029 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);
1035 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1037 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1043 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1045 /* mark&release old frames */
1046 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]) {
1047 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1048 if (s->last_picture_ptr->owner2 == s)
1049 free_frame_buffer(s, s->last_picture_ptr);
1051 /* release forgotten pictures */
1052 /* if(mpeg124/h263) */
1054 for(i=0; i<s->picture_count; i++){
1055 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].f.reference) {
1056 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1057 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1058 free_frame_buffer(s, &s->picture[i]);
1066 ff_release_unused_pictures(s, 1);
1068 if (s->current_picture_ptr && s->current_picture_ptr->f.data[0] == NULL)
1069 pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1071 i= ff_find_unused_picture(s, 0);
1072 pic= &s->picture[i];
1075 pic->f.reference = 0;
1077 if (s->codec_id == CODEC_ID_H264)
1078 pic->f.reference = s->picture_structure;
1079 else if (s->pict_type != AV_PICTURE_TYPE_B)
1080 pic->f.reference = 3;
1083 pic->f.coded_picture_number = s->coded_picture_number++;
1085 if(ff_alloc_picture(s, pic, 0) < 0)
1088 s->current_picture_ptr= pic;
1089 //FIXME use only the vars from current_pic
1090 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1091 if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1092 if(s->picture_structure != PICT_FRAME)
1093 s->current_picture_ptr->f.top_field_first = (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1095 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame && !s->progressive_sequence;
1096 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1099 s->current_picture_ptr->f.pict_type = s->pict_type;
1100 // if(s->flags && CODEC_FLAG_QSCALE)
1101 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1102 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1104 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1106 if (s->pict_type != AV_PICTURE_TYPE_B) {
1107 s->last_picture_ptr= s->next_picture_ptr;
1109 s->next_picture_ptr= s->current_picture_ptr;
1111 /* 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,
1112 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1113 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1114 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1115 s->pict_type, s->dropable);*/
1117 if(s->codec_id != CODEC_ID_H264){
1118 if ((s->last_picture_ptr == NULL || s->last_picture_ptr->f.data[0] == NULL) &&
1119 (s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1120 if (s->pict_type != AV_PICTURE_TYPE_I)
1121 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1122 else if (s->picture_structure != PICT_FRAME)
1123 av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1125 /* Allocate a dummy frame */
1126 i= ff_find_unused_picture(s, 0);
1127 s->last_picture_ptr= &s->picture[i];
1128 s->last_picture_ptr->f.key_frame = 0;
1129 if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1131 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1132 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1134 if ((s->next_picture_ptr == NULL || s->next_picture_ptr->f.data[0] == NULL) && s->pict_type == AV_PICTURE_TYPE_B) {
1135 /* Allocate a dummy frame */
1136 i= ff_find_unused_picture(s, 0);
1137 s->next_picture_ptr= &s->picture[i];
1138 s->next_picture_ptr->f.key_frame = 0;
1139 if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1141 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1142 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1146 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1147 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1149 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->f.data[0]));
1151 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1154 if(s->picture_structure == PICT_BOTTOM_FIELD){
1155 s->current_picture.f.data[i] += s->current_picture.f.linesize[i];
1157 s->current_picture.f.linesize[i] *= 2;
1158 s->last_picture.f.linesize[i] *= 2;
1159 s->next_picture.f.linesize[i] *= 2;
1163 s->error_recognition= avctx->error_recognition;
1165 /* set dequantizer, we can't do it during init as it might change for mpeg4
1166 and we can't do it in the header decode as init is not called for mpeg4 there yet */
1167 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1168 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1169 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1170 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1171 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1172 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1174 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1175 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1178 if(s->dct_error_sum){
1179 assert(s->avctx->noise_reduction && s->encoding);
1181 update_noise_reduction(s);
1184 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1185 return ff_xvmc_field_start(s, avctx);
1190 /* generic function for encode/decode called after a frame has been coded/decoded */
1191 void MPV_frame_end(MpegEncContext *s)
1194 /* redraw edges for the frame if decoding didn't complete */
1195 //just to make sure that all data is rendered.
1196 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1197 ff_xvmc_field_end(s);
1198 }else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND))
1199 && !s->avctx->hwaccel
1200 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1201 && s->unrestricted_mv
1202 && s->current_picture.f.reference
1204 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1205 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1206 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1207 s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1208 s->h_edge_pos , s->v_edge_pos,
1209 EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1210 s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1211 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1212 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1213 s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1214 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1215 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1220 s->last_pict_type = s->pict_type;
1221 s->last_lambda_for[s->pict_type] = s->current_picture_ptr->f.quality;
1222 if(s->pict_type!=AV_PICTURE_TYPE_B){
1223 s->last_non_b_pict_type= s->pict_type;
1226 /* copy back current_picture variables */
1227 for(i=0; i<MAX_PICTURE_COUNT; i++){
1228 if(s->picture[i].f.data[0] == s->current_picture.f.data[0]){
1229 s->picture[i]= s->current_picture;
1233 assert(i<MAX_PICTURE_COUNT);
1237 /* release non-reference frames */
1238 for(i=0; i<s->picture_count; i++){
1239 if (s->picture[i].f.data[0] && !s->picture[i].f.reference /*&& s->picture[i].type != FF_BUFFER_TYPE_SHARED*/) {
1240 free_frame_buffer(s, &s->picture[i]);
1244 // clear copies, to avoid confusion
1246 memset(&s->last_picture, 0, sizeof(Picture));
1247 memset(&s->next_picture, 0, sizeof(Picture));
1248 memset(&s->current_picture, 0, sizeof(Picture));
1250 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1252 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1253 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1258 * draws an line from (ex, ey) -> (sx, sy).
1259 * @param w width of the image
1260 * @param h height of the image
1261 * @param stride stride/linesize of the image
1262 * @param color color of the arrow
1264 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1267 sx= av_clip(sx, 0, w-1);
1268 sy= av_clip(sy, 0, h-1);
1269 ex= av_clip(ex, 0, w-1);
1270 ey= av_clip(ey, 0, h-1);
1272 buf[sy*stride + sx]+= color;
1274 if(FFABS(ex - sx) > FFABS(ey - sy)){
1276 FFSWAP(int, sx, ex);
1277 FFSWAP(int, sy, ey);
1279 buf+= sx + sy*stride;
1281 f= ((ey-sy)<<16)/ex;
1282 for(x= 0; x <= ex; x++){
1285 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1286 buf[(y+1)*stride + x]+= (color* fr )>>16;
1290 FFSWAP(int, sx, ex);
1291 FFSWAP(int, sy, ey);
1293 buf+= sx + sy*stride;
1295 if(ey) f= ((ex-sx)<<16)/ey;
1297 for(y= 0; y <= ey; y++){
1300 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1301 buf[y*stride + x+1]+= (color* fr )>>16;
1307 * draws an arrow from (ex, ey) -> (sx, sy).
1308 * @param w width of the image
1309 * @param h height of the image
1310 * @param stride stride/linesize of the image
1311 * @param color color of the arrow
1313 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1316 sx= av_clip(sx, -100, w+100);
1317 sy= av_clip(sy, -100, h+100);
1318 ex= av_clip(ex, -100, w+100);
1319 ey= av_clip(ey, -100, h+100);
1324 if(dx*dx + dy*dy > 3*3){
1327 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1329 //FIXME subpixel accuracy
1330 rx= ROUNDED_DIV(rx*3<<4, length);
1331 ry= ROUNDED_DIV(ry*3<<4, length);
1333 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1334 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1336 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1340 * prints debuging info for the given picture.
1342 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1344 if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1346 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1349 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1350 av_get_picture_type_char(pict->pict_type));
1351 for(y=0; y<s->mb_height; y++){
1352 for(x=0; x<s->mb_width; x++){
1353 if(s->avctx->debug&FF_DEBUG_SKIP){
1354 int count= s->mbskip_table[x + y*s->mb_stride];
1355 if(count>9) count=9;
1356 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1358 if(s->avctx->debug&FF_DEBUG_QP){
1359 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1361 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1362 int mb_type= pict->mb_type[x + y*s->mb_stride];
1363 //Type & MV direction
1365 av_log(s->avctx, AV_LOG_DEBUG, "P");
1366 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1367 av_log(s->avctx, AV_LOG_DEBUG, "A");
1368 else if(IS_INTRA4x4(mb_type))
1369 av_log(s->avctx, AV_LOG_DEBUG, "i");
1370 else if(IS_INTRA16x16(mb_type))
1371 av_log(s->avctx, AV_LOG_DEBUG, "I");
1372 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1373 av_log(s->avctx, AV_LOG_DEBUG, "d");
1374 else if(IS_DIRECT(mb_type))
1375 av_log(s->avctx, AV_LOG_DEBUG, "D");
1376 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1377 av_log(s->avctx, AV_LOG_DEBUG, "g");
1378 else if(IS_GMC(mb_type))
1379 av_log(s->avctx, AV_LOG_DEBUG, "G");
1380 else if(IS_SKIP(mb_type))
1381 av_log(s->avctx, AV_LOG_DEBUG, "S");
1382 else if(!USES_LIST(mb_type, 1))
1383 av_log(s->avctx, AV_LOG_DEBUG, ">");
1384 else if(!USES_LIST(mb_type, 0))
1385 av_log(s->avctx, AV_LOG_DEBUG, "<");
1387 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1388 av_log(s->avctx, AV_LOG_DEBUG, "X");
1393 av_log(s->avctx, AV_LOG_DEBUG, "+");
1394 else if(IS_16X8(mb_type))
1395 av_log(s->avctx, AV_LOG_DEBUG, "-");
1396 else if(IS_8X16(mb_type))
1397 av_log(s->avctx, AV_LOG_DEBUG, "|");
1398 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1399 av_log(s->avctx, AV_LOG_DEBUG, " ");
1401 av_log(s->avctx, AV_LOG_DEBUG, "?");
1404 if(IS_INTERLACED(mb_type))
1405 av_log(s->avctx, AV_LOG_DEBUG, "=");
1407 av_log(s->avctx, AV_LOG_DEBUG, " ");
1409 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1411 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1415 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1416 const int shift= 1 + s->quarter_sample;
1420 int h_chroma_shift, v_chroma_shift, block_height;
1421 const int width = s->avctx->width;
1422 const int height= s->avctx->height;
1423 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1424 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1425 s->low_delay=0; //needed to see the vectors without trashing the buffers
1427 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1429 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1430 pict->data[i]= s->visualization_buffer[i];
1432 pict->type= FF_BUFFER_TYPE_COPY;
1435 block_height = 16>>v_chroma_shift;
1437 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1439 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1440 const int mb_index= mb_x + mb_y*s->mb_stride;
1441 if((s->avctx->debug_mv) && pict->motion_val){
1443 for(type=0; type<3; type++){
1446 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1450 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1454 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1459 if(!USES_LIST(pict->mb_type[mb_index], direction))
1462 if(IS_8X8(pict->mb_type[mb_index])){
1465 int sx= mb_x*16 + 4 + 8*(i&1);
1466 int sy= mb_y*16 + 4 + 8*(i>>1);
1467 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1468 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1469 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1470 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1472 }else if(IS_16X8(pict->mb_type[mb_index])){
1476 int sy=mb_y*16 + 4 + 8*i;
1477 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1478 int mx=(pict->motion_val[direction][xy][0]>>shift);
1479 int my=(pict->motion_val[direction][xy][1]>>shift);
1481 if(IS_INTERLACED(pict->mb_type[mb_index]))
1484 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1486 }else if(IS_8X16(pict->mb_type[mb_index])){
1489 int sx=mb_x*16 + 4 + 8*i;
1491 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1492 int mx=(pict->motion_val[direction][xy][0]>>shift);
1493 int my=(pict->motion_val[direction][xy][1]>>shift);
1495 if(IS_INTERLACED(pict->mb_type[mb_index]))
1498 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1501 int sx= mb_x*16 + 8;
1502 int sy= mb_y*16 + 8;
1503 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1504 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1505 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1506 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1510 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1511 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1513 for(y=0; y<block_height; y++){
1514 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1515 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1518 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1519 int mb_type= pict->mb_type[mb_index];
1522 #define COLOR(theta, r)\
1523 u= (int)(128 + r*cos(theta*3.141592/180));\
1524 v= (int)(128 + r*sin(theta*3.141592/180));
1528 if(IS_PCM(mb_type)){
1530 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1532 }else if(IS_INTRA4x4(mb_type)){
1534 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1536 }else if(IS_DIRECT(mb_type)){
1538 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1540 }else if(IS_GMC(mb_type)){
1542 }else if(IS_SKIP(mb_type)){
1544 }else if(!USES_LIST(mb_type, 1)){
1546 }else if(!USES_LIST(mb_type, 0)){
1549 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1553 u*= 0x0101010101010101ULL;
1554 v*= 0x0101010101010101ULL;
1555 for(y=0; y<block_height; y++){
1556 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1557 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1561 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1562 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1563 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1565 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1567 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1569 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1570 int dm= 1 << (mv_sample_log2-2);
1572 int sx= mb_x*16 + 8*(i&1);
1573 int sy= mb_y*16 + 8*(i>>1);
1574 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1576 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1577 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1579 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1580 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1581 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1585 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1589 s->mbskip_table[mb_index]=0;
1595 static inline int hpel_motion_lowres(MpegEncContext *s,
1596 uint8_t *dest, uint8_t *src,
1597 int field_based, int field_select,
1598 int src_x, int src_y,
1599 int width, int height, int stride,
1600 int h_edge_pos, int v_edge_pos,
1601 int w, int h, h264_chroma_mc_func *pix_op,
1602 int motion_x, int motion_y)
1604 const int lowres= s->avctx->lowres;
1605 const int op_index= FFMIN(lowres, 2);
1606 const int s_mask= (2<<lowres)-1;
1610 if(s->quarter_sample){
1615 sx= motion_x & s_mask;
1616 sy= motion_y & s_mask;
1617 src_x += motion_x >> (lowres+1);
1618 src_y += motion_y >> (lowres+1);
1620 src += src_y * stride + src_x;
1622 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1623 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1624 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1625 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1626 src= s->edge_emu_buffer;
1630 sx= (sx << 2) >> lowres;
1631 sy= (sy << 2) >> lowres;
1634 pix_op[op_index](dest, src, stride, h, sx, sy);
1638 /* apply one mpeg motion vector to the three components */
1639 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1640 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1641 int field_based, int bottom_field, int field_select,
1642 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1643 int motion_x, int motion_y, int h, int mb_y)
1645 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1646 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1647 const int lowres= s->avctx->lowres;
1648 const int op_index= FFMIN(lowres-1+s->chroma_x_shift, 2);
1649 const int block_s= 8>>lowres;
1650 const int s_mask= (2<<lowres)-1;
1651 const int h_edge_pos = s->h_edge_pos >> lowres;
1652 const int v_edge_pos = s->v_edge_pos >> lowres;
1653 linesize = s->current_picture.f.linesize[0] << field_based;
1654 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1656 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1662 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1665 sx= motion_x & s_mask;
1666 sy= motion_y & s_mask;
1667 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1668 src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1670 if (s->out_format == FMT_H263) {
1671 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1672 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1675 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1678 uvsx = (2*mx) & s_mask;
1679 uvsy = (2*my) & s_mask;
1680 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1681 uvsrc_y = mb_y*block_s + (my >> lowres);
1683 if(s->chroma_y_shift){
1688 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1689 uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
1691 if(s->chroma_x_shift){
1695 uvsy = motion_y & s_mask;
1697 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1700 uvsx = motion_x & s_mask;
1701 uvsy = motion_y & s_mask;
1708 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1709 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1710 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1712 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1713 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1714 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1715 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1716 ptr_y = s->edge_emu_buffer;
1717 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1718 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1719 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1720 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1721 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1722 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1728 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1729 dest_y += s->linesize;
1730 dest_cb+= s->uvlinesize;
1731 dest_cr+= s->uvlinesize;
1735 ptr_y += s->linesize;
1736 ptr_cb+= s->uvlinesize;
1737 ptr_cr+= s->uvlinesize;
1740 sx= (sx << 2) >> lowres;
1741 sy= (sy << 2) >> lowres;
1742 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1744 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1745 uvsx= (uvsx << 2) >> lowres;
1746 uvsy= (uvsy << 2) >> lowres;
1747 if(h >> s->chroma_y_shift){
1748 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1749 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1752 //FIXME h261 lowres loop filter
1755 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1756 uint8_t *dest_cb, uint8_t *dest_cr,
1757 uint8_t **ref_picture,
1758 h264_chroma_mc_func *pix_op,
1760 const int lowres= s->avctx->lowres;
1761 const int op_index= FFMIN(lowres, 2);
1762 const int block_s= 8>>lowres;
1763 const int s_mask= (2<<lowres)-1;
1764 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1765 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1766 int emu=0, src_x, src_y, offset, sx, sy;
1769 if(s->quarter_sample){
1774 /* In case of 8X8, we construct a single chroma motion vector
1775 with a special rounding */
1776 mx= ff_h263_round_chroma(mx);
1777 my= ff_h263_round_chroma(my);
1781 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1782 src_y = s->mb_y*block_s + (my >> (lowres+1));
1784 offset = src_y * s->uvlinesize + src_x;
1785 ptr = ref_picture[1] + offset;
1786 if(s->flags&CODEC_FLAG_EMU_EDGE){
1787 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1788 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1789 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1790 ptr= s->edge_emu_buffer;
1794 sx= (sx << 2) >> lowres;
1795 sy= (sy << 2) >> lowres;
1796 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1798 ptr = ref_picture[2] + offset;
1800 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1801 ptr= s->edge_emu_buffer;
1803 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1807 * motion compensation of a single macroblock
1809 * @param dest_y luma destination pointer
1810 * @param dest_cb chroma cb/u destination pointer
1811 * @param dest_cr chroma cr/v destination pointer
1812 * @param dir direction (0->forward, 1->backward)
1813 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1814 * @param pix_op halfpel motion compensation function (average or put normally)
1815 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1817 static inline void MPV_motion_lowres(MpegEncContext *s,
1818 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1819 int dir, uint8_t **ref_picture,
1820 h264_chroma_mc_func *pix_op)
1824 const int lowres= s->avctx->lowres;
1825 const int block_s= 8>>lowres;
1830 switch(s->mv_type) {
1832 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1834 ref_picture, pix_op,
1835 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1841 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1842 ref_picture[0], 0, 0,
1843 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1844 s->width, s->height, s->linesize,
1845 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1846 block_s, block_s, pix_op,
1847 s->mv[dir][i][0], s->mv[dir][i][1]);
1849 mx += s->mv[dir][i][0];
1850 my += s->mv[dir][i][1];
1853 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1854 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1857 if (s->picture_structure == PICT_FRAME) {
1859 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1860 1, 0, s->field_select[dir][0],
1861 ref_picture, pix_op,
1862 s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1864 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1865 1, 1, s->field_select[dir][1],
1866 ref_picture, pix_op,
1867 s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1869 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1870 ref_picture = s->current_picture_ptr->f.data;
1873 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1874 0, 0, s->field_select[dir][0],
1875 ref_picture, pix_op,
1876 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1881 uint8_t ** ref2picture;
1883 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1884 ref2picture= ref_picture;
1886 ref2picture = s->current_picture_ptr->f.data;
1889 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1890 0, 0, s->field_select[dir][i],
1891 ref2picture, pix_op,
1892 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1894 dest_y += 2*block_s*s->linesize;
1895 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1896 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1900 if(s->picture_structure == PICT_FRAME){
1904 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1906 ref_picture, pix_op,
1907 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1909 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1913 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1914 0, 0, s->picture_structure != i+1,
1915 ref_picture, pix_op,
1916 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1918 // after put we make avg of the same block
1919 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1921 //opposite parity is always in the same frame if this is second field
1922 if(!s->first_field){
1923 ref_picture = s->current_picture_ptr->f.data;
1933 * find the lowest MB row referenced in the MVs
1935 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1937 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1938 int my, off, i, mvs;
1940 if (s->picture_structure != PICT_FRAME) goto unhandled;
1942 switch (s->mv_type) {
1956 for (i = 0; i < mvs; i++) {
1957 my = s->mv[dir][i][1]<<qpel_shift;
1958 my_max = FFMAX(my_max, my);
1959 my_min = FFMIN(my_min, my);
1962 off = (FFMAX(-my_min, my_max) + 63) >> 6;
1964 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1966 return s->mb_height-1;
1969 /* put block[] to dest[] */
1970 static inline void put_dct(MpegEncContext *s,
1971 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1973 s->dct_unquantize_intra(s, block, i, qscale);
1974 s->dsp.idct_put (dest, line_size, block);
1977 /* add block[] to dest[] */
1978 static inline void add_dct(MpegEncContext *s,
1979 DCTELEM *block, int i, uint8_t *dest, int line_size)
1981 if (s->block_last_index[i] >= 0) {
1982 s->dsp.idct_add (dest, line_size, block);
1986 static inline void add_dequant_dct(MpegEncContext *s,
1987 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1989 if (s->block_last_index[i] >= 0) {
1990 s->dct_unquantize_inter(s, block, i, qscale);
1992 s->dsp.idct_add (dest, line_size, block);
1997 * cleans dc, ac, coded_block for the current non intra MB
1999 void ff_clean_intra_table_entries(MpegEncContext *s)
2001 int wrap = s->b8_stride;
2002 int xy = s->block_index[0];
2005 s->dc_val[0][xy + 1 ] =
2006 s->dc_val[0][xy + wrap] =
2007 s->dc_val[0][xy + 1 + wrap] = 1024;
2009 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2010 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2011 if (s->msmpeg4_version>=3) {
2012 s->coded_block[xy ] =
2013 s->coded_block[xy + 1 ] =
2014 s->coded_block[xy + wrap] =
2015 s->coded_block[xy + 1 + wrap] = 0;
2018 wrap = s->mb_stride;
2019 xy = s->mb_x + s->mb_y * wrap;
2021 s->dc_val[2][xy] = 1024;
2023 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2024 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2026 s->mbintra_table[xy]= 0;
2029 /* generic function called after a macroblock has been parsed by the
2030 decoder or after it has been encoded by the encoder.
2032 Important variables used:
2033 s->mb_intra : true if intra macroblock
2034 s->mv_dir : motion vector direction
2035 s->mv_type : motion vector type
2036 s->mv : motion vector
2037 s->interlaced_dct : true if interlaced dct used (mpeg2)
2039 static av_always_inline
2040 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2041 int lowres_flag, int is_mpeg12)
2043 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2044 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2045 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2049 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2050 /* save DCT coefficients */
2052 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2053 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2055 for(j=0; j<64; j++){
2056 *dct++ = block[i][s->dsp.idct_permutation[j]];
2057 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2059 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2063 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2065 /* update DC predictors for P macroblocks */
2067 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2068 if(s->mbintra_table[mb_xy])
2069 ff_clean_intra_table_entries(s);
2073 s->last_dc[2] = 128 << s->intra_dc_precision;
2076 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2077 s->mbintra_table[mb_xy]=1;
2079 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
2080 uint8_t *dest_y, *dest_cb, *dest_cr;
2081 int dct_linesize, dct_offset;
2082 op_pixels_func (*op_pix)[4];
2083 qpel_mc_func (*op_qpix)[16];
2084 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2085 const int uvlinesize = s->current_picture.f.linesize[1];
2086 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2087 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2089 /* avoid copy if macroblock skipped in last frame too */
2090 /* skip only during decoding as we might trash the buffers during encoding a bit */
2092 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2093 const int age = s->current_picture.f.age;
2097 if (s->mb_skipped) {
2099 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2101 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2102 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2104 /* if previous was skipped too, then nothing to do ! */
2105 if (*mbskip_ptr >= age && s->current_picture.f.reference){
2108 } else if(!s->current_picture.f.reference) {
2109 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2110 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2112 *mbskip_ptr = 0; /* not skipped */
2116 dct_linesize = linesize << s->interlaced_dct;
2117 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2121 dest_cb= s->dest[1];
2122 dest_cr= s->dest[2];
2124 dest_y = s->b_scratchpad;
2125 dest_cb= s->b_scratchpad+16*linesize;
2126 dest_cr= s->b_scratchpad+32*linesize;
2130 /* motion handling */
2131 /* decoding or more than one mb_type (MC was already done otherwise) */
2134 if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2135 if (s->mv_dir & MV_DIR_FORWARD) {
2136 ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2138 if (s->mv_dir & MV_DIR_BACKWARD) {
2139 ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2144 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2146 if (s->mv_dir & MV_DIR_FORWARD) {
2147 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2148 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2150 if (s->mv_dir & MV_DIR_BACKWARD) {
2151 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2154 op_qpix= s->me.qpel_put;
2155 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2156 op_pix = s->dsp.put_pixels_tab;
2158 op_pix = s->dsp.put_no_rnd_pixels_tab;
2160 if (s->mv_dir & MV_DIR_FORWARD) {
2161 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2162 op_pix = s->dsp.avg_pixels_tab;
2163 op_qpix= s->me.qpel_avg;
2165 if (s->mv_dir & MV_DIR_BACKWARD) {
2166 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2171 /* skip dequant / idct if we are really late ;) */
2172 if(s->avctx->skip_idct){
2173 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2174 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2175 || s->avctx->skip_idct >= AVDISCARD_ALL)
2179 /* add dct residue */
2180 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2181 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2182 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2183 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2184 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2185 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2187 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2188 if (s->chroma_y_shift){
2189 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2190 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2194 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2195 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2196 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2197 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2200 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2201 add_dct(s, block[0], 0, dest_y , dct_linesize);
2202 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2203 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2204 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2206 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2207 if(s->chroma_y_shift){//Chroma420
2208 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2209 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2212 dct_linesize = uvlinesize << s->interlaced_dct;
2213 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2215 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2216 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2217 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2218 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2219 if(!s->chroma_x_shift){//Chroma444
2220 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2221 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2222 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2223 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2228 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2229 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2232 /* dct only in intra block */
2233 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2234 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2235 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2236 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2237 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2239 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2240 if(s->chroma_y_shift){
2241 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2242 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2246 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2247 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2248 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2249 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2253 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2254 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2255 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2256 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2258 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2259 if(s->chroma_y_shift){
2260 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2261 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2264 dct_linesize = uvlinesize << s->interlaced_dct;
2265 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2267 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2268 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2269 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2270 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2271 if(!s->chroma_x_shift){//Chroma444
2272 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2273 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2274 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2275 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2283 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2284 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2285 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2290 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2292 if(s->out_format == FMT_MPEG1) {
2293 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2294 else MPV_decode_mb_internal(s, block, 0, 1);
2297 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2298 else MPV_decode_mb_internal(s, block, 0, 0);
2303 * @param h is the normal height, this will be reduced automatically if needed for the last row
2305 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2306 const int field_pic= s->picture_structure != PICT_FRAME;
2312 if (!s->avctx->hwaccel
2313 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2314 && s->unrestricted_mv
2315 && s->current_picture.f.reference
2317 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2318 int sides = 0, edge_h;
2319 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2320 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2321 if (y==0) sides |= EDGE_TOP;
2322 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2324 edge_h= FFMIN(h, s->v_edge_pos - y);
2326 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize , s->linesize,
2327 s->h_edge_pos , edge_h , EDGE_WIDTH , EDGE_WIDTH , sides);
2328 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize, s->uvlinesize,
2329 s->h_edge_pos>>hshift, edge_h>>vshift, EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2330 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize, s->uvlinesize,
2331 s->h_edge_pos>>hshift, edge_h>>vshift, EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2334 h= FFMIN(h, s->avctx->height - y);
2336 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2338 if (s->avctx->draw_horiz_band) {
2342 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2343 src= (AVFrame*)s->current_picture_ptr;
2344 else if(s->last_picture_ptr)
2345 src= (AVFrame*)s->last_picture_ptr;
2349 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2355 offset[0]= y * s->linesize;
2357 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2363 s->avctx->draw_horiz_band(s->avctx, src, offset,
2364 y, s->picture_structure, h);
2368 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2369 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2370 const int uvlinesize = s->current_picture.f.linesize[1];
2371 const int mb_size= 4 - s->avctx->lowres;
2373 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2374 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2375 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2376 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2377 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2378 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;
2379 //block_index is not used by mpeg2, so it is not affected by chroma_format
2381 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2382 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2383 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2385 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2387 if(s->picture_structure==PICT_FRAME){
2388 s->dest[0] += s->mb_y * linesize << mb_size;
2389 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2390 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2392 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2393 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2394 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2395 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2400 void ff_mpeg_flush(AVCodecContext *avctx){
2402 MpegEncContext *s = avctx->priv_data;
2404 if(s==NULL || s->picture==NULL)
2407 for(i=0; i<s->picture_count; i++){
2408 if (s->picture[i].f.data[0] &&
2409 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2410 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2411 free_frame_buffer(s, &s->picture[i]);
2413 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2415 s->mb_x= s->mb_y= 0;
2418 s->parse_context.state= -1;
2419 s->parse_context.frame_start_found= 0;
2420 s->parse_context.overread= 0;
2421 s->parse_context.overread_index= 0;
2422 s->parse_context.index= 0;
2423 s->parse_context.last_index= 0;
2424 s->bitstream_buffer_size=0;
2428 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2429 DCTELEM *block, int n, int qscale)
2431 int i, level, nCoeffs;
2432 const uint16_t *quant_matrix;
2434 nCoeffs= s->block_last_index[n];
2437 block[0] = block[0] * s->y_dc_scale;
2439 block[0] = block[0] * s->c_dc_scale;
2440 /* XXX: only mpeg1 */
2441 quant_matrix = s->intra_matrix;
2442 for(i=1;i<=nCoeffs;i++) {
2443 int j= s->intra_scantable.permutated[i];
2448 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2449 level = (level - 1) | 1;
2452 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2453 level = (level - 1) | 1;
2460 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2461 DCTELEM *block, int n, int qscale)
2463 int i, level, nCoeffs;
2464 const uint16_t *quant_matrix;
2466 nCoeffs= s->block_last_index[n];
2468 quant_matrix = s->inter_matrix;
2469 for(i=0; i<=nCoeffs; i++) {
2470 int j= s->intra_scantable.permutated[i];
2475 level = (((level << 1) + 1) * qscale *
2476 ((int) (quant_matrix[j]))) >> 4;
2477 level = (level - 1) | 1;
2480 level = (((level << 1) + 1) * qscale *
2481 ((int) (quant_matrix[j]))) >> 4;
2482 level = (level - 1) | 1;
2489 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2490 DCTELEM *block, int n, int qscale)
2492 int i, level, nCoeffs;
2493 const uint16_t *quant_matrix;
2495 if(s->alternate_scan) nCoeffs= 63;
2496 else nCoeffs= s->block_last_index[n];
2499 block[0] = block[0] * s->y_dc_scale;
2501 block[0] = block[0] * s->c_dc_scale;
2502 quant_matrix = s->intra_matrix;
2503 for(i=1;i<=nCoeffs;i++) {
2504 int j= s->intra_scantable.permutated[i];
2509 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2512 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2519 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2520 DCTELEM *block, int n, int qscale)
2522 int i, level, nCoeffs;
2523 const uint16_t *quant_matrix;
2526 if(s->alternate_scan) nCoeffs= 63;
2527 else nCoeffs= s->block_last_index[n];
2530 block[0] = block[0] * s->y_dc_scale;
2532 block[0] = block[0] * s->c_dc_scale;
2533 quant_matrix = s->intra_matrix;
2534 for(i=1;i<=nCoeffs;i++) {
2535 int j= s->intra_scantable.permutated[i];
2540 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2543 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2552 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2553 DCTELEM *block, int n, int qscale)
2555 int i, level, nCoeffs;
2556 const uint16_t *quant_matrix;
2559 if(s->alternate_scan) nCoeffs= 63;
2560 else nCoeffs= s->block_last_index[n];
2562 quant_matrix = s->inter_matrix;
2563 for(i=0; i<=nCoeffs; i++) {
2564 int j= s->intra_scantable.permutated[i];
2569 level = (((level << 1) + 1) * qscale *
2570 ((int) (quant_matrix[j]))) >> 4;
2573 level = (((level << 1) + 1) * qscale *
2574 ((int) (quant_matrix[j]))) >> 4;
2583 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2584 DCTELEM *block, int n, int qscale)
2586 int i, level, qmul, qadd;
2589 assert(s->block_last_index[n]>=0);
2595 block[0] = block[0] * s->y_dc_scale;
2597 block[0] = block[0] * s->c_dc_scale;
2598 qadd = (qscale - 1) | 1;
2605 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2607 for(i=1; i<=nCoeffs; i++) {
2611 level = level * qmul - qadd;
2613 level = level * qmul + qadd;
2620 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2621 DCTELEM *block, int n, int qscale)
2623 int i, level, qmul, qadd;
2626 assert(s->block_last_index[n]>=0);
2628 qadd = (qscale - 1) | 1;
2631 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2633 for(i=0; i<=nCoeffs; i++) {
2637 level = level * qmul - qadd;
2639 level = level * qmul + qadd;
2647 * set qscale and update qscale dependent variables.
2649 void ff_set_qscale(MpegEncContext * s, int qscale)
2653 else if (qscale > 31)
2657 s->chroma_qscale= s->chroma_qscale_table[qscale];
2659 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2660 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2663 void MPV_report_decode_progress(MpegEncContext *s)
2665 if (s->pict_type != FF_B_TYPE && !s->partitioned_frame && !s->error_occurred)
2666 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);