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 *avpriv_mpv_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 = avpriv_toupper4(s->avctx->codec_tag);
649 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
651 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
653 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
654 for(y=0; y<s->mb_height; y++){
655 for(x=0; x<s->mb_width; x++){
656 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
659 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
662 /* Allocate MV tables */
663 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
664 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
665 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
666 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
667 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
668 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
669 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
670 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
671 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
672 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
673 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
674 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
676 if(s->msmpeg4_version){
677 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
679 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
681 /* Allocate MB type table */
682 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
684 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
686 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
687 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix , 64*32 * sizeof(int), fail)
688 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
689 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
690 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
691 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
692 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
693 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
695 if(s->avctx->noise_reduction){
696 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
700 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
701 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
702 for(i = 0; i < s->picture_count; i++) {
703 avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
706 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
708 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
709 /* interlaced direct mode decoding tables */
714 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
715 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
717 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
718 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
719 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
721 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
724 if (s->out_format == FMT_H263) {
726 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
727 s->coded_block= s->coded_block_base + s->b8_stride + 1;
729 /* cbp, ac_pred, pred_dir */
730 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail)
731 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
734 if (s->h263_pred || s->h263_plus || !s->encoding) {
736 //MN: we need these for error resilience of intra-frames
737 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
738 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
739 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
740 s->dc_val[2] = s->dc_val[1] + c_size;
741 for(i=0;i<yc_size;i++)
742 s->dc_val_base[i] = 1024;
745 /* which mb is a intra block */
746 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
747 memset(s->mbintra_table, 1, mb_array_size);
749 /* init macroblock skip table */
750 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
751 //Note the +1 is for a quicker mpeg4 slice_end detection
752 FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
754 s->parse_context.state= -1;
755 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
756 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
757 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
758 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
761 s->context_initialized = 1;
762 s->thread_context[0]= s;
764 if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
765 for(i=1; i<threads; i++){
766 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
767 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
770 for(i=0; i<threads; i++){
771 if(init_duplicate_context(s->thread_context[i], s) < 0)
773 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
774 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
777 if(init_duplicate_context(s, s) < 0) goto fail;
779 s->end_mb_y = s->mb_height;
789 /* init common structure for both encoder and decoder */
790 void MPV_common_end(MpegEncContext *s)
794 if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
795 for(i=0; i<s->avctx->thread_count; i++){
796 free_duplicate_context(s->thread_context[i]);
798 for(i=1; i<s->avctx->thread_count; i++){
799 av_freep(&s->thread_context[i]);
801 } else free_duplicate_context(s);
803 av_freep(&s->parse_context.buffer);
804 s->parse_context.buffer_size=0;
806 av_freep(&s->mb_type);
807 av_freep(&s->p_mv_table_base);
808 av_freep(&s->b_forw_mv_table_base);
809 av_freep(&s->b_back_mv_table_base);
810 av_freep(&s->b_bidir_forw_mv_table_base);
811 av_freep(&s->b_bidir_back_mv_table_base);
812 av_freep(&s->b_direct_mv_table_base);
814 s->b_forw_mv_table= NULL;
815 s->b_back_mv_table= NULL;
816 s->b_bidir_forw_mv_table= NULL;
817 s->b_bidir_back_mv_table= NULL;
818 s->b_direct_mv_table= NULL;
822 av_freep(&s->b_field_mv_table_base[i][j][k]);
823 s->b_field_mv_table[i][j][k]=NULL;
825 av_freep(&s->b_field_select_table[i][j]);
826 av_freep(&s->p_field_mv_table_base[i][j]);
827 s->p_field_mv_table[i][j]=NULL;
829 av_freep(&s->p_field_select_table[i]);
832 av_freep(&s->dc_val_base);
833 av_freep(&s->coded_block_base);
834 av_freep(&s->mbintra_table);
835 av_freep(&s->cbp_table);
836 av_freep(&s->pred_dir_table);
838 av_freep(&s->mbskip_table);
839 av_freep(&s->prev_pict_types);
840 av_freep(&s->bitstream_buffer);
841 s->allocated_bitstream_buffer_size=0;
843 av_freep(&s->avctx->stats_out);
844 av_freep(&s->ac_stats);
845 av_freep(&s->error_status_table);
846 av_freep(&s->mb_index2xy);
847 av_freep(&s->lambda_table);
848 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
849 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
850 s->q_chroma_intra_matrix= NULL;
851 s->q_chroma_intra_matrix16= NULL;
852 av_freep(&s->q_intra_matrix);
853 av_freep(&s->q_inter_matrix);
854 av_freep(&s->q_intra_matrix16);
855 av_freep(&s->q_inter_matrix16);
856 av_freep(&s->input_picture);
857 av_freep(&s->reordered_input_picture);
858 av_freep(&s->dct_offset);
860 if(s->picture && !s->avctx->is_copy){
861 for(i=0; i<s->picture_count; i++){
862 free_picture(s, &s->picture[i]);
865 av_freep(&s->picture);
866 s->context_initialized = 0;
869 s->current_picture_ptr= NULL;
870 s->linesize= s->uvlinesize= 0;
873 av_freep(&s->visualization_buffer[i]);
875 if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
876 avcodec_default_free_buffers(s->avctx);
879 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
881 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
882 uint8_t index_run[MAX_RUN+1];
883 int last, run, level, start, end, i;
885 /* If table is static, we can quit if rl->max_level[0] is not NULL */
886 if(static_store && rl->max_level[0])
889 /* compute max_level[], max_run[] and index_run[] */
890 for(last=0;last<2;last++) {
899 memset(max_level, 0, MAX_RUN + 1);
900 memset(max_run, 0, MAX_LEVEL + 1);
901 memset(index_run, rl->n, MAX_RUN + 1);
902 for(i=start;i<end;i++) {
903 run = rl->table_run[i];
904 level = rl->table_level[i];
905 if (index_run[run] == rl->n)
907 if (level > max_level[run])
908 max_level[run] = level;
909 if (run > max_run[level])
910 max_run[level] = run;
913 rl->max_level[last] = static_store[last];
915 rl->max_level[last] = av_malloc(MAX_RUN + 1);
916 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
918 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
920 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
921 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
923 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
925 rl->index_run[last] = av_malloc(MAX_RUN + 1);
926 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
930 void init_vlc_rl(RLTable *rl)
942 for(i=0; i<rl->vlc.table_size; i++){
943 int code= rl->vlc.table[i][0];
944 int len = rl->vlc.table[i][1];
947 if(len==0){ // illegal code
950 }else if(len<0){ //more bits needed
954 if(code==rl->n){ //esc
958 run= rl->table_run [code] + 1;
959 level= rl->table_level[code] * qmul + qadd;
960 if(code >= rl->last) run+=192;
963 rl->rl_vlc[q][i].len= len;
964 rl->rl_vlc[q][i].level= level;
965 rl->rl_vlc[q][i].run= run;
970 void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
974 /* release non reference frames */
975 for(i=0; i<s->picture_count; i++){
976 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
977 && (!s->picture[i].owner2 || s->picture[i].owner2 == s)
978 && (remove_current || &s->picture[i] != s->current_picture_ptr)
979 /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
980 free_frame_buffer(s, &s->picture[i]);
985 int ff_find_unused_picture(MpegEncContext *s, int shared){
989 for(i=s->picture_range_start; i<s->picture_range_end; i++){
990 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
994 for(i=s->picture_range_start; i<s->picture_range_end; i++){
995 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
998 for(i=s->picture_range_start; i<s->picture_range_end; i++){
999 if (s->picture[i].f.data[0] == NULL)
1004 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
1005 /* We could return -1, but the codec would crash trying to draw into a
1006 * non-existing frame anyway. This is safer than waiting for a random crash.
1007 * Also the return of this is never useful, an encoder must only allocate
1008 * as much as allowed in the specification. This has no relationship to how
1009 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1010 * enough for such valid streams).
1011 * Plus, a decoder has to check stream validity and remove frames if too
1012 * many reference frames are around. Waiting for "OOM" is not correct at
1013 * all. Similarly, missing reference frames have to be replaced by
1014 * interpolated/MC frames, anything else is a bug in the codec ...
1020 static void update_noise_reduction(MpegEncContext *s){
1023 for(intra=0; intra<2; intra++){
1024 if(s->dct_count[intra] > (1<<16)){
1025 for(i=0; i<64; i++){
1026 s->dct_error_sum[intra][i] >>=1;
1028 s->dct_count[intra] >>= 1;
1031 for(i=0; i<64; i++){
1032 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);
1038 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1040 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1046 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1048 /* mark&release old frames */
1049 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]) {
1050 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1051 if (s->last_picture_ptr->owner2 == s)
1052 free_frame_buffer(s, s->last_picture_ptr);
1054 /* release forgotten pictures */
1055 /* if(mpeg124/h263) */
1057 for(i=0; i<s->picture_count; i++){
1058 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].f.reference) {
1059 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1060 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1061 free_frame_buffer(s, &s->picture[i]);
1069 ff_release_unused_pictures(s, 1);
1071 if (s->current_picture_ptr && s->current_picture_ptr->f.data[0] == NULL)
1072 pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1074 i= ff_find_unused_picture(s, 0);
1075 pic= &s->picture[i];
1078 pic->f.reference = 0;
1080 if (s->codec_id == CODEC_ID_H264)
1081 pic->f.reference = s->picture_structure;
1082 else if (s->pict_type != AV_PICTURE_TYPE_B)
1083 pic->f.reference = 3;
1086 pic->f.coded_picture_number = s->coded_picture_number++;
1088 if(ff_alloc_picture(s, pic, 0) < 0)
1091 s->current_picture_ptr= pic;
1092 //FIXME use only the vars from current_pic
1093 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1094 if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1095 if(s->picture_structure != PICT_FRAME)
1096 s->current_picture_ptr->f.top_field_first = (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1098 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame && !s->progressive_sequence;
1099 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1102 s->current_picture_ptr->f.pict_type = s->pict_type;
1103 // if(s->flags && CODEC_FLAG_QSCALE)
1104 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1105 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1107 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1109 if (s->pict_type != AV_PICTURE_TYPE_B) {
1110 s->last_picture_ptr= s->next_picture_ptr;
1112 s->next_picture_ptr= s->current_picture_ptr;
1114 /* 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,
1115 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1116 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1117 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1118 s->pict_type, s->dropable);*/
1120 if(s->codec_id != CODEC_ID_H264){
1121 if ((s->last_picture_ptr == NULL || s->last_picture_ptr->f.data[0] == NULL) &&
1122 (s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1123 if (s->pict_type != AV_PICTURE_TYPE_I)
1124 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1125 else if (s->picture_structure != PICT_FRAME)
1126 av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1128 /* Allocate a dummy frame */
1129 i= ff_find_unused_picture(s, 0);
1130 s->last_picture_ptr= &s->picture[i];
1131 s->last_picture_ptr->f.key_frame = 0;
1132 if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1135 if(s->codec_id == CODEC_ID_FLV1){
1136 for(i=0; i<s->height; i++)
1137 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, s->width);
1140 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1141 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1143 if ((s->next_picture_ptr == NULL || s->next_picture_ptr->f.data[0] == NULL) && s->pict_type == AV_PICTURE_TYPE_B) {
1144 /* Allocate a dummy frame */
1145 i= ff_find_unused_picture(s, 0);
1146 s->next_picture_ptr= &s->picture[i];
1147 s->next_picture_ptr->f.key_frame = 0;
1148 if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1150 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1151 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1155 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1156 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1158 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->f.data[0]));
1160 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1163 if(s->picture_structure == PICT_BOTTOM_FIELD){
1164 s->current_picture.f.data[i] += s->current_picture.f.linesize[i];
1166 s->current_picture.f.linesize[i] *= 2;
1167 s->last_picture.f.linesize[i] *= 2;
1168 s->next_picture.f.linesize[i] *= 2;
1172 s->error_recognition= avctx->error_recognition;
1174 /* set dequantizer, we can't do it during init as it might change for mpeg4
1175 and we can't do it in the header decode as init is not called for mpeg4 there yet */
1176 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1177 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1178 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1179 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1180 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1181 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1183 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1184 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1187 if(s->dct_error_sum){
1188 assert(s->avctx->noise_reduction && s->encoding);
1190 update_noise_reduction(s);
1193 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1194 return ff_xvmc_field_start(s, avctx);
1199 /* generic function for encode/decode called after a frame has been coded/decoded */
1200 void MPV_frame_end(MpegEncContext *s)
1203 /* redraw edges for the frame if decoding didn't complete */
1204 //just to make sure that all data is rendered.
1205 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1206 ff_xvmc_field_end(s);
1207 }else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND))
1208 && !s->avctx->hwaccel
1209 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1210 && s->unrestricted_mv
1211 && s->current_picture.f.reference
1213 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1214 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1215 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1216 s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1217 s->h_edge_pos , s->v_edge_pos,
1218 EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1219 s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1220 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1221 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1222 s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1223 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1224 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1229 s->last_pict_type = s->pict_type;
1230 s->last_lambda_for[s->pict_type] = s->current_picture_ptr->f.quality;
1231 if(s->pict_type!=AV_PICTURE_TYPE_B){
1232 s->last_non_b_pict_type= s->pict_type;
1235 /* copy back current_picture variables */
1236 for(i=0; i<MAX_PICTURE_COUNT; i++){
1237 if(s->picture[i].f.data[0] == s->current_picture.f.data[0]){
1238 s->picture[i]= s->current_picture;
1242 assert(i<MAX_PICTURE_COUNT);
1246 /* release non-reference frames */
1247 for(i=0; i<s->picture_count; i++){
1248 if (s->picture[i].f.data[0] && !s->picture[i].f.reference /*&& s->picture[i].type != FF_BUFFER_TYPE_SHARED*/) {
1249 free_frame_buffer(s, &s->picture[i]);
1253 // clear copies, to avoid confusion
1255 memset(&s->last_picture, 0, sizeof(Picture));
1256 memset(&s->next_picture, 0, sizeof(Picture));
1257 memset(&s->current_picture, 0, sizeof(Picture));
1259 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1261 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1262 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1267 * draws an line from (ex, ey) -> (sx, sy).
1268 * @param w width of the image
1269 * @param h height of the image
1270 * @param stride stride/linesize of the image
1271 * @param color color of the arrow
1273 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1276 sx= av_clip(sx, 0, w-1);
1277 sy= av_clip(sy, 0, h-1);
1278 ex= av_clip(ex, 0, w-1);
1279 ey= av_clip(ey, 0, h-1);
1281 buf[sy*stride + sx]+= color;
1283 if(FFABS(ex - sx) > FFABS(ey - sy)){
1285 FFSWAP(int, sx, ex);
1286 FFSWAP(int, sy, ey);
1288 buf+= sx + sy*stride;
1290 f= ((ey-sy)<<16)/ex;
1291 for(x= 0; x <= ex; x++){
1294 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1295 buf[(y+1)*stride + x]+= (color* fr )>>16;
1299 FFSWAP(int, sx, ex);
1300 FFSWAP(int, sy, ey);
1302 buf+= sx + sy*stride;
1304 if(ey) f= ((ex-sx)<<16)/ey;
1306 for(y= 0; y <= ey; y++){
1309 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1310 buf[y*stride + x+1]+= (color* fr )>>16;
1316 * draws an arrow from (ex, ey) -> (sx, sy).
1317 * @param w width of the image
1318 * @param h height of the image
1319 * @param stride stride/linesize of the image
1320 * @param color color of the arrow
1322 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1325 sx= av_clip(sx, -100, w+100);
1326 sy= av_clip(sy, -100, h+100);
1327 ex= av_clip(ex, -100, w+100);
1328 ey= av_clip(ey, -100, h+100);
1333 if(dx*dx + dy*dy > 3*3){
1336 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1338 //FIXME subpixel accuracy
1339 rx= ROUNDED_DIV(rx*3<<4, length);
1340 ry= ROUNDED_DIV(ry*3<<4, length);
1342 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1343 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1345 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1349 * prints debuging info for the given picture.
1351 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1353 if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1355 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1358 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1359 av_get_picture_type_char(pict->pict_type));
1360 for(y=0; y<s->mb_height; y++){
1361 for(x=0; x<s->mb_width; x++){
1362 if(s->avctx->debug&FF_DEBUG_SKIP){
1363 int count= s->mbskip_table[x + y*s->mb_stride];
1364 if(count>9) count=9;
1365 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1367 if(s->avctx->debug&FF_DEBUG_QP){
1368 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1370 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1371 int mb_type= pict->mb_type[x + y*s->mb_stride];
1372 //Type & MV direction
1374 av_log(s->avctx, AV_LOG_DEBUG, "P");
1375 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1376 av_log(s->avctx, AV_LOG_DEBUG, "A");
1377 else if(IS_INTRA4x4(mb_type))
1378 av_log(s->avctx, AV_LOG_DEBUG, "i");
1379 else if(IS_INTRA16x16(mb_type))
1380 av_log(s->avctx, AV_LOG_DEBUG, "I");
1381 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1382 av_log(s->avctx, AV_LOG_DEBUG, "d");
1383 else if(IS_DIRECT(mb_type))
1384 av_log(s->avctx, AV_LOG_DEBUG, "D");
1385 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1386 av_log(s->avctx, AV_LOG_DEBUG, "g");
1387 else if(IS_GMC(mb_type))
1388 av_log(s->avctx, AV_LOG_DEBUG, "G");
1389 else if(IS_SKIP(mb_type))
1390 av_log(s->avctx, AV_LOG_DEBUG, "S");
1391 else if(!USES_LIST(mb_type, 1))
1392 av_log(s->avctx, AV_LOG_DEBUG, ">");
1393 else if(!USES_LIST(mb_type, 0))
1394 av_log(s->avctx, AV_LOG_DEBUG, "<");
1396 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1397 av_log(s->avctx, AV_LOG_DEBUG, "X");
1402 av_log(s->avctx, AV_LOG_DEBUG, "+");
1403 else if(IS_16X8(mb_type))
1404 av_log(s->avctx, AV_LOG_DEBUG, "-");
1405 else if(IS_8X16(mb_type))
1406 av_log(s->avctx, AV_LOG_DEBUG, "|");
1407 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1408 av_log(s->avctx, AV_LOG_DEBUG, " ");
1410 av_log(s->avctx, AV_LOG_DEBUG, "?");
1413 if(IS_INTERLACED(mb_type))
1414 av_log(s->avctx, AV_LOG_DEBUG, "=");
1416 av_log(s->avctx, AV_LOG_DEBUG, " ");
1418 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1420 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1424 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1425 const int shift= 1 + s->quarter_sample;
1429 int h_chroma_shift, v_chroma_shift, block_height;
1430 const int width = s->avctx->width;
1431 const int height= s->avctx->height;
1432 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1433 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1434 s->low_delay=0; //needed to see the vectors without trashing the buffers
1436 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1438 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1439 pict->data[i]= s->visualization_buffer[i];
1441 pict->type= FF_BUFFER_TYPE_COPY;
1444 block_height = 16>>v_chroma_shift;
1446 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1448 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1449 const int mb_index= mb_x + mb_y*s->mb_stride;
1450 if((s->avctx->debug_mv) && pict->motion_val){
1452 for(type=0; type<3; type++){
1455 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1459 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1463 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1468 if(!USES_LIST(pict->mb_type[mb_index], direction))
1471 if(IS_8X8(pict->mb_type[mb_index])){
1474 int sx= mb_x*16 + 4 + 8*(i&1);
1475 int sy= mb_y*16 + 4 + 8*(i>>1);
1476 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1477 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1478 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1479 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1481 }else if(IS_16X8(pict->mb_type[mb_index])){
1485 int sy=mb_y*16 + 4 + 8*i;
1486 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1487 int mx=(pict->motion_val[direction][xy][0]>>shift);
1488 int my=(pict->motion_val[direction][xy][1]>>shift);
1490 if(IS_INTERLACED(pict->mb_type[mb_index]))
1493 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1495 }else if(IS_8X16(pict->mb_type[mb_index])){
1498 int sx=mb_x*16 + 4 + 8*i;
1500 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1501 int mx=(pict->motion_val[direction][xy][0]>>shift);
1502 int my=(pict->motion_val[direction][xy][1]>>shift);
1504 if(IS_INTERLACED(pict->mb_type[mb_index]))
1507 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1510 int sx= mb_x*16 + 8;
1511 int sy= mb_y*16 + 8;
1512 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1513 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1514 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1515 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1519 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1520 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1522 for(y=0; y<block_height; y++){
1523 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1524 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1527 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1528 int mb_type= pict->mb_type[mb_index];
1531 #define COLOR(theta, r)\
1532 u= (int)(128 + r*cos(theta*3.141592/180));\
1533 v= (int)(128 + r*sin(theta*3.141592/180));
1537 if(IS_PCM(mb_type)){
1539 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1541 }else if(IS_INTRA4x4(mb_type)){
1543 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1545 }else if(IS_DIRECT(mb_type)){
1547 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1549 }else if(IS_GMC(mb_type)){
1551 }else if(IS_SKIP(mb_type)){
1553 }else if(!USES_LIST(mb_type, 1)){
1555 }else if(!USES_LIST(mb_type, 0)){
1558 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1562 u*= 0x0101010101010101ULL;
1563 v*= 0x0101010101010101ULL;
1564 for(y=0; y<block_height; y++){
1565 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1566 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1570 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1571 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1572 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1574 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1576 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1578 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1579 int dm= 1 << (mv_sample_log2-2);
1581 int sx= mb_x*16 + 8*(i&1);
1582 int sy= mb_y*16 + 8*(i>>1);
1583 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1585 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1586 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1588 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1589 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1590 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1594 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1598 s->mbskip_table[mb_index]=0;
1604 static inline int hpel_motion_lowres(MpegEncContext *s,
1605 uint8_t *dest, uint8_t *src,
1606 int field_based, int field_select,
1607 int src_x, int src_y,
1608 int width, int height, int stride,
1609 int h_edge_pos, int v_edge_pos,
1610 int w, int h, h264_chroma_mc_func *pix_op,
1611 int motion_x, int motion_y)
1613 const int lowres= s->avctx->lowres;
1614 const int op_index= FFMIN(lowres, 2);
1615 const int s_mask= (2<<lowres)-1;
1619 if(s->quarter_sample){
1624 sx= motion_x & s_mask;
1625 sy= motion_y & s_mask;
1626 src_x += motion_x >> (lowres+1);
1627 src_y += motion_y >> (lowres+1);
1629 src += src_y * stride + src_x;
1631 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1632 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1633 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1634 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1635 src= s->edge_emu_buffer;
1639 sx= (sx << 2) >> lowres;
1640 sy= (sy << 2) >> lowres;
1643 pix_op[op_index](dest, src, stride, h, sx, sy);
1647 /* apply one mpeg motion vector to the three components */
1648 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1649 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1650 int field_based, int bottom_field, int field_select,
1651 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1652 int motion_x, int motion_y, int h, int mb_y)
1654 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1655 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1656 const int lowres= s->avctx->lowres;
1657 const int op_index= FFMIN(lowres-1+s->chroma_x_shift, 2);
1658 const int block_s= 8>>lowres;
1659 const int s_mask= (2<<lowres)-1;
1660 const int h_edge_pos = s->h_edge_pos >> lowres;
1661 const int v_edge_pos = s->v_edge_pos >> lowres;
1662 linesize = s->current_picture.f.linesize[0] << field_based;
1663 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1665 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1671 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1674 sx= motion_x & s_mask;
1675 sy= motion_y & s_mask;
1676 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1677 src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1679 if (s->out_format == FMT_H263) {
1680 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1681 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1684 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1687 uvsx = (2*mx) & s_mask;
1688 uvsy = (2*my) & s_mask;
1689 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1690 uvsrc_y = mb_y*block_s + (my >> lowres);
1692 if(s->chroma_y_shift){
1697 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1698 uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
1700 if(s->chroma_x_shift){
1704 uvsy = motion_y & s_mask;
1706 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1709 uvsx = motion_x & s_mask;
1710 uvsy = motion_y & s_mask;
1717 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1718 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1719 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1721 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1722 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1723 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1724 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1725 ptr_y = s->edge_emu_buffer;
1726 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1727 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1728 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1729 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1730 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1731 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1737 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1738 dest_y += s->linesize;
1739 dest_cb+= s->uvlinesize;
1740 dest_cr+= s->uvlinesize;
1744 ptr_y += s->linesize;
1745 ptr_cb+= s->uvlinesize;
1746 ptr_cr+= s->uvlinesize;
1749 sx= (sx << 2) >> lowres;
1750 sy= (sy << 2) >> lowres;
1751 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1753 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1754 uvsx= (uvsx << 2) >> lowres;
1755 uvsy= (uvsy << 2) >> lowres;
1756 if(h >> s->chroma_y_shift){
1757 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1758 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1761 //FIXME h261 lowres loop filter
1764 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1765 uint8_t *dest_cb, uint8_t *dest_cr,
1766 uint8_t **ref_picture,
1767 h264_chroma_mc_func *pix_op,
1769 const int lowres= s->avctx->lowres;
1770 const int op_index= FFMIN(lowres, 2);
1771 const int block_s= 8>>lowres;
1772 const int s_mask= (2<<lowres)-1;
1773 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1774 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1775 int emu=0, src_x, src_y, offset, sx, sy;
1778 if(s->quarter_sample){
1783 /* In case of 8X8, we construct a single chroma motion vector
1784 with a special rounding */
1785 mx= ff_h263_round_chroma(mx);
1786 my= ff_h263_round_chroma(my);
1790 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1791 src_y = s->mb_y*block_s + (my >> (lowres+1));
1793 offset = src_y * s->uvlinesize + src_x;
1794 ptr = ref_picture[1] + offset;
1795 if(s->flags&CODEC_FLAG_EMU_EDGE){
1796 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1797 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1798 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1799 ptr= s->edge_emu_buffer;
1803 sx= (sx << 2) >> lowres;
1804 sy= (sy << 2) >> lowres;
1805 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1807 ptr = ref_picture[2] + offset;
1809 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1810 ptr= s->edge_emu_buffer;
1812 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1816 * motion compensation of a single macroblock
1818 * @param dest_y luma destination pointer
1819 * @param dest_cb chroma cb/u destination pointer
1820 * @param dest_cr chroma cr/v destination pointer
1821 * @param dir direction (0->forward, 1->backward)
1822 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1823 * @param pix_op halfpel motion compensation function (average or put normally)
1824 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1826 static inline void MPV_motion_lowres(MpegEncContext *s,
1827 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1828 int dir, uint8_t **ref_picture,
1829 h264_chroma_mc_func *pix_op)
1833 const int lowres= s->avctx->lowres;
1834 const int block_s= 8>>lowres;
1839 switch(s->mv_type) {
1841 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1843 ref_picture, pix_op,
1844 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1850 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1851 ref_picture[0], 0, 0,
1852 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1853 s->width, s->height, s->linesize,
1854 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1855 block_s, block_s, pix_op,
1856 s->mv[dir][i][0], s->mv[dir][i][1]);
1858 mx += s->mv[dir][i][0];
1859 my += s->mv[dir][i][1];
1862 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1863 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1866 if (s->picture_structure == PICT_FRAME) {
1868 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1869 1, 0, s->field_select[dir][0],
1870 ref_picture, pix_op,
1871 s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1873 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1874 1, 1, s->field_select[dir][1],
1875 ref_picture, pix_op,
1876 s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1878 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1879 ref_picture = s->current_picture_ptr->f.data;
1882 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1883 0, 0, s->field_select[dir][0],
1884 ref_picture, pix_op,
1885 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1890 uint8_t ** ref2picture;
1892 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1893 ref2picture= ref_picture;
1895 ref2picture = s->current_picture_ptr->f.data;
1898 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1899 0, 0, s->field_select[dir][i],
1900 ref2picture, pix_op,
1901 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1903 dest_y += 2*block_s*s->linesize;
1904 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1905 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1909 if(s->picture_structure == PICT_FRAME){
1913 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1915 ref_picture, pix_op,
1916 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1918 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1922 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1923 0, 0, s->picture_structure != i+1,
1924 ref_picture, pix_op,
1925 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1927 // after put we make avg of the same block
1928 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1930 //opposite parity is always in the same frame if this is second field
1931 if(!s->first_field){
1932 ref_picture = s->current_picture_ptr->f.data;
1942 * find the lowest MB row referenced in the MVs
1944 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1946 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1947 int my, off, i, mvs;
1949 if (s->picture_structure != PICT_FRAME) goto unhandled;
1951 switch (s->mv_type) {
1965 for (i = 0; i < mvs; i++) {
1966 my = s->mv[dir][i][1]<<qpel_shift;
1967 my_max = FFMAX(my_max, my);
1968 my_min = FFMIN(my_min, my);
1971 off = (FFMAX(-my_min, my_max) + 63) >> 6;
1973 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1975 return s->mb_height-1;
1978 /* put block[] to dest[] */
1979 static inline void put_dct(MpegEncContext *s,
1980 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1982 s->dct_unquantize_intra(s, block, i, qscale);
1983 s->dsp.idct_put (dest, line_size, block);
1986 /* add block[] to dest[] */
1987 static inline void add_dct(MpegEncContext *s,
1988 DCTELEM *block, int i, uint8_t *dest, int line_size)
1990 if (s->block_last_index[i] >= 0) {
1991 s->dsp.idct_add (dest, line_size, block);
1995 static inline void add_dequant_dct(MpegEncContext *s,
1996 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1998 if (s->block_last_index[i] >= 0) {
1999 s->dct_unquantize_inter(s, block, i, qscale);
2001 s->dsp.idct_add (dest, line_size, block);
2006 * cleans dc, ac, coded_block for the current non intra MB
2008 void ff_clean_intra_table_entries(MpegEncContext *s)
2010 int wrap = s->b8_stride;
2011 int xy = s->block_index[0];
2014 s->dc_val[0][xy + 1 ] =
2015 s->dc_val[0][xy + wrap] =
2016 s->dc_val[0][xy + 1 + wrap] = 1024;
2018 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2019 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2020 if (s->msmpeg4_version>=3) {
2021 s->coded_block[xy ] =
2022 s->coded_block[xy + 1 ] =
2023 s->coded_block[xy + wrap] =
2024 s->coded_block[xy + 1 + wrap] = 0;
2027 wrap = s->mb_stride;
2028 xy = s->mb_x + s->mb_y * wrap;
2030 s->dc_val[2][xy] = 1024;
2032 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2033 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2035 s->mbintra_table[xy]= 0;
2038 /* generic function called after a macroblock has been parsed by the
2039 decoder or after it has been encoded by the encoder.
2041 Important variables used:
2042 s->mb_intra : true if intra macroblock
2043 s->mv_dir : motion vector direction
2044 s->mv_type : motion vector type
2045 s->mv : motion vector
2046 s->interlaced_dct : true if interlaced dct used (mpeg2)
2048 static av_always_inline
2049 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2050 int lowres_flag, int is_mpeg12)
2052 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2053 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2054 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2058 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2059 /* save DCT coefficients */
2061 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2062 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2064 for(j=0; j<64; j++){
2065 *dct++ = block[i][s->dsp.idct_permutation[j]];
2066 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2068 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2072 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2074 /* update DC predictors for P macroblocks */
2076 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2077 if(s->mbintra_table[mb_xy])
2078 ff_clean_intra_table_entries(s);
2082 s->last_dc[2] = 128 << s->intra_dc_precision;
2085 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2086 s->mbintra_table[mb_xy]=1;
2088 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
2089 uint8_t *dest_y, *dest_cb, *dest_cr;
2090 int dct_linesize, dct_offset;
2091 op_pixels_func (*op_pix)[4];
2092 qpel_mc_func (*op_qpix)[16];
2093 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2094 const int uvlinesize = s->current_picture.f.linesize[1];
2095 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2096 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2098 /* avoid copy if macroblock skipped in last frame too */
2099 /* skip only during decoding as we might trash the buffers during encoding a bit */
2101 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2102 const int age = s->current_picture.f.age;
2106 if (s->mb_skipped) {
2108 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2110 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2111 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2113 /* if previous was skipped too, then nothing to do ! */
2114 if (*mbskip_ptr >= age && s->current_picture.f.reference){
2117 } else if(!s->current_picture.f.reference) {
2118 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2119 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2121 *mbskip_ptr = 0; /* not skipped */
2125 dct_linesize = linesize << s->interlaced_dct;
2126 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2130 dest_cb= s->dest[1];
2131 dest_cr= s->dest[2];
2133 dest_y = s->b_scratchpad;
2134 dest_cb= s->b_scratchpad+16*linesize;
2135 dest_cr= s->b_scratchpad+32*linesize;
2139 /* motion handling */
2140 /* decoding or more than one mb_type (MC was already done otherwise) */
2143 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2144 if (s->mv_dir & MV_DIR_FORWARD) {
2145 ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2147 if (s->mv_dir & MV_DIR_BACKWARD) {
2148 ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2153 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2155 if (s->mv_dir & MV_DIR_FORWARD) {
2156 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2157 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2159 if (s->mv_dir & MV_DIR_BACKWARD) {
2160 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2163 op_qpix= s->me.qpel_put;
2164 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2165 op_pix = s->dsp.put_pixels_tab;
2167 op_pix = s->dsp.put_no_rnd_pixels_tab;
2169 if (s->mv_dir & MV_DIR_FORWARD) {
2170 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2171 op_pix = s->dsp.avg_pixels_tab;
2172 op_qpix= s->me.qpel_avg;
2174 if (s->mv_dir & MV_DIR_BACKWARD) {
2175 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2180 /* skip dequant / idct if we are really late ;) */
2181 if(s->avctx->skip_idct){
2182 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2183 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2184 || s->avctx->skip_idct >= AVDISCARD_ALL)
2188 /* add dct residue */
2189 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2190 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2191 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2192 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2193 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2194 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2196 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2197 if (s->chroma_y_shift){
2198 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2199 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2203 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2204 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2205 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2206 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2209 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2210 add_dct(s, block[0], 0, dest_y , dct_linesize);
2211 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2212 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2213 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2215 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2216 if(s->chroma_y_shift){//Chroma420
2217 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2218 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2221 dct_linesize = uvlinesize << s->interlaced_dct;
2222 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2224 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2225 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2226 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2227 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2228 if(!s->chroma_x_shift){//Chroma444
2229 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2230 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2231 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2232 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2237 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2238 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2241 /* dct only in intra block */
2242 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2243 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2244 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2245 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2246 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2248 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2249 if(s->chroma_y_shift){
2250 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2251 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2255 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2256 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2257 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2258 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2262 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2263 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2264 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2265 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2267 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2268 if(s->chroma_y_shift){
2269 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2270 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2273 dct_linesize = uvlinesize << s->interlaced_dct;
2274 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*block_size;
2276 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2277 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2278 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2279 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2280 if(!s->chroma_x_shift){//Chroma444
2281 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2282 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2283 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2284 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2292 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2293 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2294 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2299 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2301 if(s->out_format == FMT_MPEG1) {
2302 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2303 else MPV_decode_mb_internal(s, block, 0, 1);
2306 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2307 else MPV_decode_mb_internal(s, block, 0, 0);
2312 * @param h is the normal height, this will be reduced automatically if needed for the last row
2314 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2315 const int field_pic= s->picture_structure != PICT_FRAME;
2321 if (!s->avctx->hwaccel
2322 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2323 && s->unrestricted_mv
2324 && s->current_picture.f.reference
2326 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2327 int sides = 0, edge_h;
2328 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2329 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2330 if (y==0) sides |= EDGE_TOP;
2331 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2333 edge_h= FFMIN(h, s->v_edge_pos - y);
2335 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2336 s->linesize, s->h_edge_pos, edge_h,
2337 EDGE_WIDTH, EDGE_WIDTH, sides);
2338 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2339 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2340 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2341 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2342 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2343 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2346 h= FFMIN(h, s->avctx->height - y);
2348 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2350 if (s->avctx->draw_horiz_band) {
2354 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2355 src= (AVFrame*)s->current_picture_ptr;
2356 else if(s->last_picture_ptr)
2357 src= (AVFrame*)s->last_picture_ptr;
2361 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2367 offset[0]= y * s->linesize;
2369 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2375 s->avctx->draw_horiz_band(s->avctx, src, offset,
2376 y, s->picture_structure, h);
2380 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2381 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2382 const int uvlinesize = s->current_picture.f.linesize[1];
2383 const int mb_size= 4 - s->avctx->lowres;
2385 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2386 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2387 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2388 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2389 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2390 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;
2391 //block_index is not used by mpeg2, so it is not affected by chroma_format
2393 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2394 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2395 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2397 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2399 if(s->picture_structure==PICT_FRAME){
2400 s->dest[0] += s->mb_y * linesize << mb_size;
2401 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2402 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2404 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2405 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2406 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2407 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2412 void ff_mpeg_flush(AVCodecContext *avctx){
2414 MpegEncContext *s = avctx->priv_data;
2416 if(s==NULL || s->picture==NULL)
2419 for(i=0; i<s->picture_count; i++){
2420 if (s->picture[i].f.data[0] &&
2421 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2422 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2423 free_frame_buffer(s, &s->picture[i]);
2425 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2427 s->mb_x= s->mb_y= 0;
2430 s->parse_context.state= -1;
2431 s->parse_context.frame_start_found= 0;
2432 s->parse_context.overread= 0;
2433 s->parse_context.overread_index= 0;
2434 s->parse_context.index= 0;
2435 s->parse_context.last_index= 0;
2436 s->bitstream_buffer_size=0;
2440 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2441 DCTELEM *block, int n, int qscale)
2443 int i, level, nCoeffs;
2444 const uint16_t *quant_matrix;
2446 nCoeffs= s->block_last_index[n];
2449 block[0] = block[0] * s->y_dc_scale;
2451 block[0] = block[0] * s->c_dc_scale;
2452 /* XXX: only mpeg1 */
2453 quant_matrix = s->intra_matrix;
2454 for(i=1;i<=nCoeffs;i++) {
2455 int j= s->intra_scantable.permutated[i];
2460 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2461 level = (level - 1) | 1;
2464 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2465 level = (level - 1) | 1;
2472 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2473 DCTELEM *block, int n, int qscale)
2475 int i, level, nCoeffs;
2476 const uint16_t *quant_matrix;
2478 nCoeffs= s->block_last_index[n];
2480 quant_matrix = s->inter_matrix;
2481 for(i=0; i<=nCoeffs; i++) {
2482 int j= s->intra_scantable.permutated[i];
2487 level = (((level << 1) + 1) * qscale *
2488 ((int) (quant_matrix[j]))) >> 4;
2489 level = (level - 1) | 1;
2492 level = (((level << 1) + 1) * qscale *
2493 ((int) (quant_matrix[j]))) >> 4;
2494 level = (level - 1) | 1;
2501 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2502 DCTELEM *block, int n, int qscale)
2504 int i, level, nCoeffs;
2505 const uint16_t *quant_matrix;
2507 if(s->alternate_scan) nCoeffs= 63;
2508 else nCoeffs= s->block_last_index[n];
2511 block[0] = block[0] * s->y_dc_scale;
2513 block[0] = block[0] * s->c_dc_scale;
2514 quant_matrix = s->intra_matrix;
2515 for(i=1;i<=nCoeffs;i++) {
2516 int j= s->intra_scantable.permutated[i];
2521 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2524 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2531 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2532 DCTELEM *block, int n, int qscale)
2534 int i, level, nCoeffs;
2535 const uint16_t *quant_matrix;
2538 if(s->alternate_scan) nCoeffs= 63;
2539 else nCoeffs= s->block_last_index[n];
2542 block[0] = block[0] * s->y_dc_scale;
2544 block[0] = block[0] * s->c_dc_scale;
2545 quant_matrix = s->intra_matrix;
2546 for(i=1;i<=nCoeffs;i++) {
2547 int j= s->intra_scantable.permutated[i];
2552 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2555 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2564 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2565 DCTELEM *block, int n, int qscale)
2567 int i, level, nCoeffs;
2568 const uint16_t *quant_matrix;
2571 if(s->alternate_scan) nCoeffs= 63;
2572 else nCoeffs= s->block_last_index[n];
2574 quant_matrix = s->inter_matrix;
2575 for(i=0; i<=nCoeffs; i++) {
2576 int j= s->intra_scantable.permutated[i];
2581 level = (((level << 1) + 1) * qscale *
2582 ((int) (quant_matrix[j]))) >> 4;
2585 level = (((level << 1) + 1) * qscale *
2586 ((int) (quant_matrix[j]))) >> 4;
2595 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2596 DCTELEM *block, int n, int qscale)
2598 int i, level, qmul, qadd;
2601 assert(s->block_last_index[n]>=0);
2607 block[0] = block[0] * s->y_dc_scale;
2609 block[0] = block[0] * s->c_dc_scale;
2610 qadd = (qscale - 1) | 1;
2617 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2619 for(i=1; i<=nCoeffs; i++) {
2623 level = level * qmul - qadd;
2625 level = level * qmul + qadd;
2632 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2633 DCTELEM *block, int n, int qscale)
2635 int i, level, qmul, qadd;
2638 assert(s->block_last_index[n]>=0);
2640 qadd = (qscale - 1) | 1;
2643 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2645 for(i=0; i<=nCoeffs; i++) {
2649 level = level * qmul - qadd;
2651 level = level * qmul + qadd;
2659 * set qscale and update qscale dependent variables.
2661 void ff_set_qscale(MpegEncContext * s, int qscale)
2665 else if (qscale > 31)
2669 s->chroma_qscale= s->chroma_qscale_table[qscale];
2671 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2672 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2675 void MPV_report_decode_progress(MpegEncContext *s)
2677 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2678 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);