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 Libav.
10 * Libav 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 * Libav 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 Libav; 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 if (s->width && s->height) {
620 s->mb_width = (s->width + 15) / 16;
621 s->mb_stride = s->mb_width + 1;
622 s->b8_stride = s->mb_width*2 + 1;
623 s->b4_stride = s->mb_width*4 + 1;
624 mb_array_size= s->mb_height * s->mb_stride;
625 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
627 /* set chroma shifts */
628 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
629 &(s->chroma_y_shift) );
631 /* set default edge pos, will be overriden in decode_header if needed */
632 s->h_edge_pos= s->mb_width*16;
633 s->v_edge_pos= s->mb_height*16;
635 s->mb_num = s->mb_width * s->mb_height;
640 s->block_wrap[3]= s->b8_stride;
642 s->block_wrap[5]= s->mb_stride;
644 y_size = s->b8_stride * (2 * s->mb_height + 1);
645 c_size = s->mb_stride * (s->mb_height + 1);
646 yc_size = y_size + 2 * c_size;
648 /* convert fourcc to upper case */
649 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
651 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
653 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
655 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
656 for(y=0; y<s->mb_height; y++){
657 for(x=0; x<s->mb_width; x++){
658 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
661 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
664 /* Allocate MV tables */
665 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
666 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
667 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
668 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
669 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
670 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
671 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
672 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
673 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
674 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
675 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
676 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
678 if(s->msmpeg4_version){
679 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
681 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
683 /* Allocate MB type table */
684 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
686 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
688 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
689 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
690 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
691 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_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)
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 if (s->width && s->height) {
708 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
710 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
711 /* interlaced direct mode decoding tables */
716 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
717 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
719 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
720 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
721 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
723 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
726 if (s->out_format == FMT_H263) {
728 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
729 s->coded_block= s->coded_block_base + s->b8_stride + 1;
731 /* cbp, ac_pred, pred_dir */
732 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail)
733 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
736 if (s->h263_pred || s->h263_plus || !s->encoding) {
738 //MN: we need these for error resilience of intra-frames
739 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
740 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
741 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
742 s->dc_val[2] = s->dc_val[1] + c_size;
743 for(i=0;i<yc_size;i++)
744 s->dc_val_base[i] = 1024;
747 /* which mb is a intra block */
748 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
749 memset(s->mbintra_table, 1, mb_array_size);
751 /* init macroblock skip table */
752 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
753 //Note the +1 is for a quicker mpeg4 slice_end detection
754 FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
756 s->parse_context.state= -1;
757 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
758 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
759 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
760 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
764 s->context_initialized = 1;
765 s->thread_context[0]= s;
767 if (s->width && s->height) {
768 if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
769 for(i=1; i<threads; i++){
770 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
771 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
774 for(i=0; i<threads; i++){
775 if(init_duplicate_context(s->thread_context[i], s) < 0)
777 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
778 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
781 if(init_duplicate_context(s, s) < 0) goto fail;
783 s->end_mb_y = s->mb_height;
793 /* init common structure for both encoder and decoder */
794 void MPV_common_end(MpegEncContext *s)
798 if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
799 for(i=0; i<s->avctx->thread_count; i++){
800 free_duplicate_context(s->thread_context[i]);
802 for(i=1; i<s->avctx->thread_count; i++){
803 av_freep(&s->thread_context[i]);
805 } else free_duplicate_context(s);
807 av_freep(&s->parse_context.buffer);
808 s->parse_context.buffer_size=0;
810 av_freep(&s->mb_type);
811 av_freep(&s->p_mv_table_base);
812 av_freep(&s->b_forw_mv_table_base);
813 av_freep(&s->b_back_mv_table_base);
814 av_freep(&s->b_bidir_forw_mv_table_base);
815 av_freep(&s->b_bidir_back_mv_table_base);
816 av_freep(&s->b_direct_mv_table_base);
818 s->b_forw_mv_table= NULL;
819 s->b_back_mv_table= NULL;
820 s->b_bidir_forw_mv_table= NULL;
821 s->b_bidir_back_mv_table= NULL;
822 s->b_direct_mv_table= NULL;
826 av_freep(&s->b_field_mv_table_base[i][j][k]);
827 s->b_field_mv_table[i][j][k]=NULL;
829 av_freep(&s->b_field_select_table[i][j]);
830 av_freep(&s->p_field_mv_table_base[i][j]);
831 s->p_field_mv_table[i][j]=NULL;
833 av_freep(&s->p_field_select_table[i]);
836 av_freep(&s->dc_val_base);
837 av_freep(&s->coded_block_base);
838 av_freep(&s->mbintra_table);
839 av_freep(&s->cbp_table);
840 av_freep(&s->pred_dir_table);
842 av_freep(&s->mbskip_table);
843 av_freep(&s->prev_pict_types);
844 av_freep(&s->bitstream_buffer);
845 s->allocated_bitstream_buffer_size=0;
847 av_freep(&s->avctx->stats_out);
848 av_freep(&s->ac_stats);
849 av_freep(&s->error_status_table);
850 av_freep(&s->mb_index2xy);
851 av_freep(&s->lambda_table);
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 if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1133 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1134 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1136 if ((s->next_picture_ptr == NULL || s->next_picture_ptr->f.data[0] == NULL) && s->pict_type == AV_PICTURE_TYPE_B) {
1137 /* Allocate a dummy frame */
1138 i= ff_find_unused_picture(s, 0);
1139 s->next_picture_ptr= &s->picture[i];
1140 if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1142 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1143 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1147 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1148 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1150 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->f.data[0]));
1152 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1155 if(s->picture_structure == PICT_BOTTOM_FIELD){
1156 s->current_picture.f.data[i] += s->current_picture.f.linesize[i];
1158 s->current_picture.f.linesize[i] *= 2;
1159 s->last_picture.f.linesize[i] *= 2;
1160 s->next_picture.f.linesize[i] *= 2;
1164 s->error_recognition= avctx->error_recognition;
1166 /* set dequantizer, we can't do it during init as it might change for mpeg4
1167 and we can't do it in the header decode as init is not called for mpeg4 there yet */
1168 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1169 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1170 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1171 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1172 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1173 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1175 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1176 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1179 if(s->dct_error_sum){
1180 assert(s->avctx->noise_reduction && s->encoding);
1182 update_noise_reduction(s);
1185 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1186 return ff_xvmc_field_start(s, avctx);
1191 /* generic function for encode/decode called after a frame has been coded/decoded */
1192 void MPV_frame_end(MpegEncContext *s)
1195 /* redraw edges for the frame if decoding didn't complete */
1196 //just to make sure that all data is rendered.
1197 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1198 ff_xvmc_field_end(s);
1199 }else if((s->error_count || s->encoding)
1200 && !s->avctx->hwaccel
1201 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1202 && s->unrestricted_mv
1203 && s->current_picture.f.reference
1205 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1206 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1207 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1208 s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1209 s->h_edge_pos , s->v_edge_pos,
1210 EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1211 s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1212 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1213 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1214 s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1215 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1216 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1221 s->last_pict_type = s->pict_type;
1222 s->last_lambda_for[s->pict_type] = s->current_picture_ptr->f.quality;
1223 if(s->pict_type!=AV_PICTURE_TYPE_B){
1224 s->last_non_b_pict_type= s->pict_type;
1227 /* copy back current_picture variables */
1228 for(i=0; i<MAX_PICTURE_COUNT; i++){
1229 if(s->picture[i].f.data[0] == s->current_picture.f.data[0]){
1230 s->picture[i]= s->current_picture;
1234 assert(i<MAX_PICTURE_COUNT);
1238 /* release non-reference frames */
1239 for(i=0; i<s->picture_count; i++){
1240 if (s->picture[i].f.data[0] && !s->picture[i].f.reference /*&& s->picture[i].type != FF_BUFFER_TYPE_SHARED*/) {
1241 free_frame_buffer(s, &s->picture[i]);
1245 // clear copies, to avoid confusion
1247 memset(&s->last_picture, 0, sizeof(Picture));
1248 memset(&s->next_picture, 0, sizeof(Picture));
1249 memset(&s->current_picture, 0, sizeof(Picture));
1251 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1253 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1254 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1259 * draws an line from (ex, ey) -> (sx, sy).
1260 * @param w width of the image
1261 * @param h height of the image
1262 * @param stride stride/linesize of the image
1263 * @param color color of the arrow
1265 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1268 sx= av_clip(sx, 0, w-1);
1269 sy= av_clip(sy, 0, h-1);
1270 ex= av_clip(ex, 0, w-1);
1271 ey= av_clip(ey, 0, h-1);
1273 buf[sy*stride + sx]+= color;
1275 if(FFABS(ex - sx) > FFABS(ey - sy)){
1277 FFSWAP(int, sx, ex);
1278 FFSWAP(int, sy, ey);
1280 buf+= sx + sy*stride;
1282 f= ((ey-sy)<<16)/ex;
1283 for(x= 0; x <= ex; x++){
1286 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1287 buf[(y+1)*stride + x]+= (color* fr )>>16;
1291 FFSWAP(int, sx, ex);
1292 FFSWAP(int, sy, ey);
1294 buf+= sx + sy*stride;
1296 if(ey) f= ((ex-sx)<<16)/ey;
1298 for(y= 0; y <= ey; y++){
1301 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1302 buf[y*stride + x+1]+= (color* fr )>>16;
1308 * draws an arrow from (ex, ey) -> (sx, sy).
1309 * @param w width of the image
1310 * @param h height of the image
1311 * @param stride stride/linesize of the image
1312 * @param color color of the arrow
1314 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1317 sx= av_clip(sx, -100, w+100);
1318 sy= av_clip(sy, -100, h+100);
1319 ex= av_clip(ex, -100, w+100);
1320 ey= av_clip(ey, -100, h+100);
1325 if(dx*dx + dy*dy > 3*3){
1328 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1330 //FIXME subpixel accuracy
1331 rx= ROUNDED_DIV(rx*3<<4, length);
1332 ry= ROUNDED_DIV(ry*3<<4, length);
1334 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1335 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1337 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1341 * prints debuging info for the given picture.
1343 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1345 if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1347 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1350 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1351 switch (pict->pict_type) {
1352 case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1353 case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1354 case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1355 case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1356 case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1357 case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1359 for(y=0; y<s->mb_height; y++){
1360 for(x=0; x<s->mb_width; x++){
1361 if(s->avctx->debug&FF_DEBUG_SKIP){
1362 int count= s->mbskip_table[x + y*s->mb_stride];
1363 if(count>9) count=9;
1364 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1366 if(s->avctx->debug&FF_DEBUG_QP){
1367 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1369 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1370 int mb_type= pict->mb_type[x + y*s->mb_stride];
1371 //Type & MV direction
1373 av_log(s->avctx, AV_LOG_DEBUG, "P");
1374 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1375 av_log(s->avctx, AV_LOG_DEBUG, "A");
1376 else if(IS_INTRA4x4(mb_type))
1377 av_log(s->avctx, AV_LOG_DEBUG, "i");
1378 else if(IS_INTRA16x16(mb_type))
1379 av_log(s->avctx, AV_LOG_DEBUG, "I");
1380 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1381 av_log(s->avctx, AV_LOG_DEBUG, "d");
1382 else if(IS_DIRECT(mb_type))
1383 av_log(s->avctx, AV_LOG_DEBUG, "D");
1384 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1385 av_log(s->avctx, AV_LOG_DEBUG, "g");
1386 else if(IS_GMC(mb_type))
1387 av_log(s->avctx, AV_LOG_DEBUG, "G");
1388 else if(IS_SKIP(mb_type))
1389 av_log(s->avctx, AV_LOG_DEBUG, "S");
1390 else if(!USES_LIST(mb_type, 1))
1391 av_log(s->avctx, AV_LOG_DEBUG, ">");
1392 else if(!USES_LIST(mb_type, 0))
1393 av_log(s->avctx, AV_LOG_DEBUG, "<");
1395 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1396 av_log(s->avctx, AV_LOG_DEBUG, "X");
1401 av_log(s->avctx, AV_LOG_DEBUG, "+");
1402 else if(IS_16X8(mb_type))
1403 av_log(s->avctx, AV_LOG_DEBUG, "-");
1404 else if(IS_8X16(mb_type))
1405 av_log(s->avctx, AV_LOG_DEBUG, "|");
1406 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1407 av_log(s->avctx, AV_LOG_DEBUG, " ");
1409 av_log(s->avctx, AV_LOG_DEBUG, "?");
1412 if(IS_INTERLACED(mb_type))
1413 av_log(s->avctx, AV_LOG_DEBUG, "=");
1415 av_log(s->avctx, AV_LOG_DEBUG, " ");
1417 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1419 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1423 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1424 const int shift= 1 + s->quarter_sample;
1428 int h_chroma_shift, v_chroma_shift, block_height;
1429 const int width = s->avctx->width;
1430 const int height= s->avctx->height;
1431 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1432 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1433 s->low_delay=0; //needed to see the vectors without trashing the buffers
1435 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1437 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1438 pict->data[i]= s->visualization_buffer[i];
1440 pict->type= FF_BUFFER_TYPE_COPY;
1442 block_height = 16>>v_chroma_shift;
1444 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1446 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1447 const int mb_index= mb_x + mb_y*s->mb_stride;
1448 if((s->avctx->debug_mv) && pict->motion_val){
1450 for(type=0; type<3; type++){
1453 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1457 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1461 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1466 if(!USES_LIST(pict->mb_type[mb_index], direction))
1469 if(IS_8X8(pict->mb_type[mb_index])){
1472 int sx= mb_x*16 + 4 + 8*(i&1);
1473 int sy= mb_y*16 + 4 + 8*(i>>1);
1474 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1475 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1476 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1477 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1479 }else if(IS_16X8(pict->mb_type[mb_index])){
1483 int sy=mb_y*16 + 4 + 8*i;
1484 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1485 int mx=(pict->motion_val[direction][xy][0]>>shift);
1486 int my=(pict->motion_val[direction][xy][1]>>shift);
1488 if(IS_INTERLACED(pict->mb_type[mb_index]))
1491 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1493 }else if(IS_8X16(pict->mb_type[mb_index])){
1496 int sx=mb_x*16 + 4 + 8*i;
1498 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1499 int mx=(pict->motion_val[direction][xy][0]>>shift);
1500 int my=(pict->motion_val[direction][xy][1]>>shift);
1502 if(IS_INTERLACED(pict->mb_type[mb_index]))
1505 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1508 int sx= mb_x*16 + 8;
1509 int sy= mb_y*16 + 8;
1510 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1511 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1512 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1513 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1517 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1518 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1520 for(y=0; y<block_height; y++){
1521 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1522 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1525 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1526 int mb_type= pict->mb_type[mb_index];
1529 #define COLOR(theta, r)\
1530 u= (int)(128 + r*cos(theta*3.141592/180));\
1531 v= (int)(128 + r*sin(theta*3.141592/180));
1535 if(IS_PCM(mb_type)){
1537 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1539 }else if(IS_INTRA4x4(mb_type)){
1541 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1543 }else if(IS_DIRECT(mb_type)){
1545 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1547 }else if(IS_GMC(mb_type)){
1549 }else if(IS_SKIP(mb_type)){
1551 }else if(!USES_LIST(mb_type, 1)){
1553 }else if(!USES_LIST(mb_type, 0)){
1556 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1560 u*= 0x0101010101010101ULL;
1561 v*= 0x0101010101010101ULL;
1562 for(y=0; y<block_height; y++){
1563 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1564 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1568 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1569 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1570 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1572 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1574 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1576 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1577 int dm= 1 << (mv_sample_log2-2);
1579 int sx= mb_x*16 + 8*(i&1);
1580 int sy= mb_y*16 + 8*(i>>1);
1581 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1583 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1584 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1586 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1587 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1588 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1592 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1596 s->mbskip_table[mb_index]=0;
1602 static inline int hpel_motion_lowres(MpegEncContext *s,
1603 uint8_t *dest, uint8_t *src,
1604 int field_based, int field_select,
1605 int src_x, int src_y,
1606 int width, int height, int stride,
1607 int h_edge_pos, int v_edge_pos,
1608 int w, int h, h264_chroma_mc_func *pix_op,
1609 int motion_x, int motion_y)
1611 const int lowres= s->avctx->lowres;
1612 const int op_index= FFMIN(lowres, 2);
1613 const int s_mask= (2<<lowres)-1;
1617 if(s->quarter_sample){
1622 sx= motion_x & s_mask;
1623 sy= motion_y & s_mask;
1624 src_x += motion_x >> (lowres+1);
1625 src_y += motion_y >> (lowres+1);
1627 src += src_y * stride + src_x;
1629 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1630 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1631 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1632 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1633 src= s->edge_emu_buffer;
1637 sx= (sx << 2) >> lowres;
1638 sy= (sy << 2) >> lowres;
1641 pix_op[op_index](dest, src, stride, h, sx, sy);
1645 /* apply one mpeg motion vector to the three components */
1646 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1647 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1648 int field_based, int bottom_field, int field_select,
1649 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1650 int motion_x, int motion_y, int h, int mb_y)
1652 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1653 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1654 const int lowres= s->avctx->lowres;
1655 const int op_index= FFMIN(lowres, 2);
1656 const int block_s= 8>>lowres;
1657 const int s_mask= (2<<lowres)-1;
1658 const int h_edge_pos = s->h_edge_pos >> lowres;
1659 const int v_edge_pos = s->v_edge_pos >> lowres;
1660 linesize = s->current_picture.f.linesize[0] << field_based;
1661 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1663 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1669 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1672 sx= motion_x & s_mask;
1673 sy= motion_y & s_mask;
1674 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1675 src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1677 if (s->out_format == FMT_H263) {
1678 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1679 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1682 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1685 uvsx = (2*mx) & s_mask;
1686 uvsy = (2*my) & s_mask;
1687 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1688 uvsrc_y = mb_y*block_s + (my >> lowres);
1694 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1695 uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
1698 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1699 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1700 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1702 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1703 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1704 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1705 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1706 ptr_y = s->edge_emu_buffer;
1707 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1708 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1709 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1710 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1711 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1712 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1718 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1719 dest_y += s->linesize;
1720 dest_cb+= s->uvlinesize;
1721 dest_cr+= s->uvlinesize;
1725 ptr_y += s->linesize;
1726 ptr_cb+= s->uvlinesize;
1727 ptr_cr+= s->uvlinesize;
1730 sx= (sx << 2) >> lowres;
1731 sy= (sy << 2) >> lowres;
1732 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1734 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1735 uvsx= (uvsx << 2) >> lowres;
1736 uvsy= (uvsy << 2) >> lowres;
1737 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1738 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1740 //FIXME h261 lowres loop filter
1743 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1744 uint8_t *dest_cb, uint8_t *dest_cr,
1745 uint8_t **ref_picture,
1746 h264_chroma_mc_func *pix_op,
1748 const int lowres= s->avctx->lowres;
1749 const int op_index= FFMIN(lowres, 2);
1750 const int block_s= 8>>lowres;
1751 const int s_mask= (2<<lowres)-1;
1752 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1753 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1754 int emu=0, src_x, src_y, offset, sx, sy;
1757 if(s->quarter_sample){
1762 /* In case of 8X8, we construct a single chroma motion vector
1763 with a special rounding */
1764 mx= ff_h263_round_chroma(mx);
1765 my= ff_h263_round_chroma(my);
1769 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1770 src_y = s->mb_y*block_s + (my >> (lowres+1));
1772 offset = src_y * s->uvlinesize + src_x;
1773 ptr = ref_picture[1] + offset;
1774 if(s->flags&CODEC_FLAG_EMU_EDGE){
1775 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1776 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1777 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1778 ptr= s->edge_emu_buffer;
1782 sx= (sx << 2) >> lowres;
1783 sy= (sy << 2) >> lowres;
1784 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1786 ptr = ref_picture[2] + offset;
1788 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1789 ptr= s->edge_emu_buffer;
1791 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1795 * motion compensation of a single macroblock
1797 * @param dest_y luma destination pointer
1798 * @param dest_cb chroma cb/u destination pointer
1799 * @param dest_cr chroma cr/v destination pointer
1800 * @param dir direction (0->forward, 1->backward)
1801 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1802 * @param pix_op halfpel motion compensation function (average or put normally)
1803 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1805 static inline void MPV_motion_lowres(MpegEncContext *s,
1806 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1807 int dir, uint8_t **ref_picture,
1808 h264_chroma_mc_func *pix_op)
1812 const int lowres= s->avctx->lowres;
1813 const int block_s= 8>>lowres;
1818 switch(s->mv_type) {
1820 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1822 ref_picture, pix_op,
1823 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1829 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1830 ref_picture[0], 0, 0,
1831 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1832 s->width, s->height, s->linesize,
1833 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1834 block_s, block_s, pix_op,
1835 s->mv[dir][i][0], s->mv[dir][i][1]);
1837 mx += s->mv[dir][i][0];
1838 my += s->mv[dir][i][1];
1841 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1842 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1845 if (s->picture_structure == PICT_FRAME) {
1847 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1848 1, 0, s->field_select[dir][0],
1849 ref_picture, pix_op,
1850 s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1852 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1853 1, 1, s->field_select[dir][1],
1854 ref_picture, pix_op,
1855 s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1857 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1858 ref_picture = s->current_picture_ptr->f.data;
1861 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1862 0, 0, s->field_select[dir][0],
1863 ref_picture, pix_op,
1864 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1869 uint8_t ** ref2picture;
1871 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1872 ref2picture= ref_picture;
1874 ref2picture = s->current_picture_ptr->f.data;
1877 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1878 0, 0, s->field_select[dir][i],
1879 ref2picture, pix_op,
1880 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1882 dest_y += 2*block_s*s->linesize;
1883 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1884 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1888 if(s->picture_structure == PICT_FRAME){
1892 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1894 ref_picture, pix_op,
1895 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1897 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1901 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1902 0, 0, s->picture_structure != i+1,
1903 ref_picture, pix_op,
1904 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1906 // after put we make avg of the same block
1907 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1909 //opposite parity is always in the same frame if this is second field
1910 if(!s->first_field){
1911 ref_picture = s->current_picture_ptr->f.data;
1921 * find the lowest MB row referenced in the MVs
1923 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1925 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1926 int my, off, i, mvs;
1928 if (s->picture_structure != PICT_FRAME) goto unhandled;
1930 switch (s->mv_type) {
1944 for (i = 0; i < mvs; i++) {
1945 my = s->mv[dir][i][1]<<qpel_shift;
1946 my_max = FFMAX(my_max, my);
1947 my_min = FFMIN(my_min, my);
1950 off = (FFMAX(-my_min, my_max) + 63) >> 6;
1952 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1954 return s->mb_height-1;
1957 /* put block[] to dest[] */
1958 static inline void put_dct(MpegEncContext *s,
1959 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1961 s->dct_unquantize_intra(s, block, i, qscale);
1962 s->dsp.idct_put (dest, line_size, block);
1965 /* add block[] to dest[] */
1966 static inline void add_dct(MpegEncContext *s,
1967 DCTELEM *block, int i, uint8_t *dest, int line_size)
1969 if (s->block_last_index[i] >= 0) {
1970 s->dsp.idct_add (dest, line_size, block);
1974 static inline void add_dequant_dct(MpegEncContext *s,
1975 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1977 if (s->block_last_index[i] >= 0) {
1978 s->dct_unquantize_inter(s, block, i, qscale);
1980 s->dsp.idct_add (dest, line_size, block);
1985 * cleans dc, ac, coded_block for the current non intra MB
1987 void ff_clean_intra_table_entries(MpegEncContext *s)
1989 int wrap = s->b8_stride;
1990 int xy = s->block_index[0];
1993 s->dc_val[0][xy + 1 ] =
1994 s->dc_val[0][xy + wrap] =
1995 s->dc_val[0][xy + 1 + wrap] = 1024;
1997 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1998 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1999 if (s->msmpeg4_version>=3) {
2000 s->coded_block[xy ] =
2001 s->coded_block[xy + 1 ] =
2002 s->coded_block[xy + wrap] =
2003 s->coded_block[xy + 1 + wrap] = 0;
2006 wrap = s->mb_stride;
2007 xy = s->mb_x + s->mb_y * wrap;
2009 s->dc_val[2][xy] = 1024;
2011 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2012 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2014 s->mbintra_table[xy]= 0;
2017 /* generic function called after a macroblock has been parsed by the
2018 decoder or after it has been encoded by the encoder.
2020 Important variables used:
2021 s->mb_intra : true if intra macroblock
2022 s->mv_dir : motion vector direction
2023 s->mv_type : motion vector type
2024 s->mv : motion vector
2025 s->interlaced_dct : true if interlaced dct used (mpeg2)
2027 static av_always_inline
2028 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2029 int lowres_flag, int is_mpeg12)
2031 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2032 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2033 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2037 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2038 /* save DCT coefficients */
2040 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2041 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2043 for(j=0; j<64; j++){
2044 *dct++ = block[i][s->dsp.idct_permutation[j]];
2045 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2047 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2051 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2053 /* update DC predictors for P macroblocks */
2055 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2056 if(s->mbintra_table[mb_xy])
2057 ff_clean_intra_table_entries(s);
2061 s->last_dc[2] = 128 << s->intra_dc_precision;
2064 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2065 s->mbintra_table[mb_xy]=1;
2067 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
2068 uint8_t *dest_y, *dest_cb, *dest_cr;
2069 int dct_linesize, dct_offset;
2070 op_pixels_func (*op_pix)[4];
2071 qpel_mc_func (*op_qpix)[16];
2072 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2073 const int uvlinesize = s->current_picture.f.linesize[1];
2074 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2075 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2077 /* avoid copy if macroblock skipped in last frame too */
2078 /* skip only during decoding as we might trash the buffers during encoding a bit */
2080 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2081 const int age = s->current_picture.f.age;
2085 if (s->mb_skipped) {
2087 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2089 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2090 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2092 /* if previous was skipped too, then nothing to do ! */
2093 if (*mbskip_ptr >= age && s->current_picture.f.reference){
2096 } else if(!s->current_picture.f.reference) {
2097 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2098 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2100 *mbskip_ptr = 0; /* not skipped */
2104 dct_linesize = linesize << s->interlaced_dct;
2105 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2109 dest_cb= s->dest[1];
2110 dest_cr= s->dest[2];
2112 dest_y = s->b_scratchpad;
2113 dest_cb= s->b_scratchpad+16*linesize;
2114 dest_cr= s->b_scratchpad+32*linesize;
2118 /* motion handling */
2119 /* decoding or more than one mb_type (MC was already done otherwise) */
2122 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2123 if (s->mv_dir & MV_DIR_FORWARD) {
2124 ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2126 if (s->mv_dir & MV_DIR_BACKWARD) {
2127 ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2132 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2134 if (s->mv_dir & MV_DIR_FORWARD) {
2135 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2136 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2138 if (s->mv_dir & MV_DIR_BACKWARD) {
2139 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2142 op_qpix= s->me.qpel_put;
2143 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2144 op_pix = s->dsp.put_pixels_tab;
2146 op_pix = s->dsp.put_no_rnd_pixels_tab;
2148 if (s->mv_dir & MV_DIR_FORWARD) {
2149 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2150 op_pix = s->dsp.avg_pixels_tab;
2151 op_qpix= s->me.qpel_avg;
2153 if (s->mv_dir & MV_DIR_BACKWARD) {
2154 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2159 /* skip dequant / idct if we are really late ;) */
2160 if(s->avctx->skip_idct){
2161 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2162 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2163 || s->avctx->skip_idct >= AVDISCARD_ALL)
2167 /* add dct residue */
2168 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2169 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2170 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2171 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2172 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2173 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2175 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2176 if (s->chroma_y_shift){
2177 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2178 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2182 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2183 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2184 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2185 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2188 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2189 add_dct(s, block[0], 0, dest_y , dct_linesize);
2190 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2191 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2192 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2194 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2195 if(s->chroma_y_shift){//Chroma420
2196 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2197 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2200 dct_linesize = uvlinesize << s->interlaced_dct;
2201 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2203 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2204 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2205 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2206 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2207 if(!s->chroma_x_shift){//Chroma444
2208 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2209 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2210 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2211 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2216 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2217 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2220 /* dct only in intra block */
2221 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2222 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2223 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2224 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2225 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2227 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2228 if(s->chroma_y_shift){
2229 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2230 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2234 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2235 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2236 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2237 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2241 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2242 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2243 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2244 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2246 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2247 if(s->chroma_y_shift){
2248 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2249 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2252 dct_linesize = uvlinesize << s->interlaced_dct;
2253 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2255 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2256 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2257 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2258 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2259 if(!s->chroma_x_shift){//Chroma444
2260 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2261 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2262 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2263 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2271 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2272 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2273 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2278 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2280 if(s->out_format == FMT_MPEG1) {
2281 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2282 else MPV_decode_mb_internal(s, block, 0, 1);
2285 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2286 else MPV_decode_mb_internal(s, block, 0, 0);
2291 * @param h is the normal height, this will be reduced automatically if needed for the last row
2293 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2294 const int field_pic= s->picture_structure != PICT_FRAME;
2300 if (!s->avctx->hwaccel
2301 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2302 && s->unrestricted_mv
2303 && s->current_picture.f.reference
2305 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2306 int sides = 0, edge_h;
2307 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2308 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2309 if (y==0) sides |= EDGE_TOP;
2310 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2312 edge_h= FFMIN(h, s->v_edge_pos - y);
2314 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2315 s->linesize, s->h_edge_pos, edge_h,
2316 EDGE_WIDTH, EDGE_WIDTH, sides);
2317 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2318 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2319 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2320 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2321 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2322 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2325 h= FFMIN(h, s->avctx->height - y);
2327 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2329 if (s->avctx->draw_horiz_band) {
2333 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2334 src= (AVFrame*)s->current_picture_ptr;
2335 else if(s->last_picture_ptr)
2336 src= (AVFrame*)s->last_picture_ptr;
2340 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2346 offset[0]= y * s->linesize;
2348 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2354 s->avctx->draw_horiz_band(s->avctx, src, offset,
2355 y, s->picture_structure, h);
2359 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2360 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2361 const int uvlinesize = s->current_picture.f.linesize[1];
2362 const int mb_size= 4 - s->avctx->lowres;
2364 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2365 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2366 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2367 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2368 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2369 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;
2370 //block_index is not used by mpeg2, so it is not affected by chroma_format
2372 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2373 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2374 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2376 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2378 if(s->picture_structure==PICT_FRAME){
2379 s->dest[0] += s->mb_y * linesize << mb_size;
2380 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2381 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2383 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2384 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2385 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2386 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2391 void ff_mpeg_flush(AVCodecContext *avctx){
2393 MpegEncContext *s = avctx->priv_data;
2395 if(s==NULL || s->picture==NULL)
2398 for(i=0; i<s->picture_count; i++){
2399 if (s->picture[i].f.data[0] &&
2400 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2401 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2402 free_frame_buffer(s, &s->picture[i]);
2404 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2406 s->mb_x= s->mb_y= 0;
2409 s->parse_context.state= -1;
2410 s->parse_context.frame_start_found= 0;
2411 s->parse_context.overread= 0;
2412 s->parse_context.overread_index= 0;
2413 s->parse_context.index= 0;
2414 s->parse_context.last_index= 0;
2415 s->bitstream_buffer_size=0;
2419 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2420 DCTELEM *block, int n, int qscale)
2422 int i, level, nCoeffs;
2423 const uint16_t *quant_matrix;
2425 nCoeffs= s->block_last_index[n];
2428 block[0] = block[0] * s->y_dc_scale;
2430 block[0] = block[0] * s->c_dc_scale;
2431 /* XXX: only mpeg1 */
2432 quant_matrix = s->intra_matrix;
2433 for(i=1;i<=nCoeffs;i++) {
2434 int j= s->intra_scantable.permutated[i];
2439 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2440 level = (level - 1) | 1;
2443 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2444 level = (level - 1) | 1;
2451 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2452 DCTELEM *block, int n, int qscale)
2454 int i, level, nCoeffs;
2455 const uint16_t *quant_matrix;
2457 nCoeffs= s->block_last_index[n];
2459 quant_matrix = s->inter_matrix;
2460 for(i=0; i<=nCoeffs; i++) {
2461 int j= s->intra_scantable.permutated[i];
2466 level = (((level << 1) + 1) * qscale *
2467 ((int) (quant_matrix[j]))) >> 4;
2468 level = (level - 1) | 1;
2471 level = (((level << 1) + 1) * qscale *
2472 ((int) (quant_matrix[j]))) >> 4;
2473 level = (level - 1) | 1;
2480 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2481 DCTELEM *block, int n, int qscale)
2483 int i, level, nCoeffs;
2484 const uint16_t *quant_matrix;
2486 if(s->alternate_scan) nCoeffs= 63;
2487 else nCoeffs= s->block_last_index[n];
2490 block[0] = block[0] * s->y_dc_scale;
2492 block[0] = block[0] * s->c_dc_scale;
2493 quant_matrix = s->intra_matrix;
2494 for(i=1;i<=nCoeffs;i++) {
2495 int j= s->intra_scantable.permutated[i];
2500 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2503 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2510 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2511 DCTELEM *block, int n, int qscale)
2513 int i, level, nCoeffs;
2514 const uint16_t *quant_matrix;
2517 if(s->alternate_scan) nCoeffs= 63;
2518 else nCoeffs= s->block_last_index[n];
2521 block[0] = block[0] * s->y_dc_scale;
2523 block[0] = block[0] * s->c_dc_scale;
2524 quant_matrix = s->intra_matrix;
2525 for(i=1;i<=nCoeffs;i++) {
2526 int j= s->intra_scantable.permutated[i];
2531 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2534 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2543 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2544 DCTELEM *block, int n, int qscale)
2546 int i, level, nCoeffs;
2547 const uint16_t *quant_matrix;
2550 if(s->alternate_scan) nCoeffs= 63;
2551 else nCoeffs= s->block_last_index[n];
2553 quant_matrix = s->inter_matrix;
2554 for(i=0; i<=nCoeffs; i++) {
2555 int j= s->intra_scantable.permutated[i];
2560 level = (((level << 1) + 1) * qscale *
2561 ((int) (quant_matrix[j]))) >> 4;
2564 level = (((level << 1) + 1) * qscale *
2565 ((int) (quant_matrix[j]))) >> 4;
2574 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2575 DCTELEM *block, int n, int qscale)
2577 int i, level, qmul, qadd;
2580 assert(s->block_last_index[n]>=0);
2586 block[0] = block[0] * s->y_dc_scale;
2588 block[0] = block[0] * s->c_dc_scale;
2589 qadd = (qscale - 1) | 1;
2596 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2598 for(i=1; i<=nCoeffs; i++) {
2602 level = level * qmul - qadd;
2604 level = level * qmul + qadd;
2611 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2612 DCTELEM *block, int n, int qscale)
2614 int i, level, qmul, qadd;
2617 assert(s->block_last_index[n]>=0);
2619 qadd = (qscale - 1) | 1;
2622 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2624 for(i=0; i<=nCoeffs; i++) {
2628 level = level * qmul - qadd;
2630 level = level * qmul + qadd;
2638 * set qscale and update qscale dependent variables.
2640 void ff_set_qscale(MpegEncContext * s, int qscale)
2644 else if (qscale > 31)
2648 s->chroma_qscale= s->chroma_qscale_table[qscale];
2650 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2651 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2654 void MPV_report_decode_progress(MpegEncContext *s)
2656 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2657 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);