FFmpeg  4.4
mpegvideo.c
Go to the documentation of this file.
1 /*
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>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
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.
14  *
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.
19  *
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
23  */
24 
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
36 
37 #include "avcodec.h"
38 #include "blockdsp.h"
39 #include "h264chroma.h"
40 #include "idctdsp.h"
41 #include "internal.h"
42 #include "mathops.h"
43 #include "mpeg_er.h"
44 #include "mpegutils.h"
45 #include "mpegvideo.h"
46 #include "mpegvideodata.h"
47 #include "mjpegenc.h"
48 #include "msmpeg4.h"
49 #include "qpeldsp.h"
50 #include "thread.h"
51 #include "wmv2.h"
52 #include <limits.h>
53 
55  int16_t *block, int n, int qscale)
56 {
57  int i, level, nCoeffs;
58  const uint16_t *quant_matrix;
59 
60  nCoeffs= s->block_last_index[n];
61 
62  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
63  /* XXX: only MPEG-1 */
64  quant_matrix = s->intra_matrix;
65  for(i=1;i<=nCoeffs;i++) {
66  int j= s->intra_scantable.permutated[i];
67  level = block[j];
68  if (level) {
69  if (level < 0) {
70  level = -level;
71  level = (int)(level * qscale * quant_matrix[j]) >> 3;
72  level = (level - 1) | 1;
73  level = -level;
74  } else {
75  level = (int)(level * qscale * quant_matrix[j]) >> 3;
76  level = (level - 1) | 1;
77  }
78  block[j] = level;
79  }
80  }
81 }
82 
84  int16_t *block, int n, int qscale)
85 {
86  int i, level, nCoeffs;
87  const uint16_t *quant_matrix;
88 
89  nCoeffs= s->block_last_index[n];
90 
91  quant_matrix = s->inter_matrix;
92  for(i=0; i<=nCoeffs; i++) {
93  int j= s->intra_scantable.permutated[i];
94  level = block[j];
95  if (level) {
96  if (level < 0) {
97  level = -level;
98  level = (((level << 1) + 1) * qscale *
99  ((int) (quant_matrix[j]))) >> 4;
100  level = (level - 1) | 1;
101  level = -level;
102  } else {
103  level = (((level << 1) + 1) * qscale *
104  ((int) (quant_matrix[j]))) >> 4;
105  level = (level - 1) | 1;
106  }
107  block[j] = level;
108  }
109  }
110 }
111 
113  int16_t *block, int n, int qscale)
114 {
115  int i, level, nCoeffs;
116  const uint16_t *quant_matrix;
117 
118  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
119  else qscale <<= 1;
120 
121  if(s->alternate_scan) nCoeffs= 63;
122  else nCoeffs= s->block_last_index[n];
123 
124  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
125  quant_matrix = s->intra_matrix;
126  for(i=1;i<=nCoeffs;i++) {
127  int j= s->intra_scantable.permutated[i];
128  level = block[j];
129  if (level) {
130  if (level < 0) {
131  level = -level;
132  level = (int)(level * qscale * quant_matrix[j]) >> 4;
133  level = -level;
134  } else {
135  level = (int)(level * qscale * quant_matrix[j]) >> 4;
136  }
137  block[j] = level;
138  }
139  }
140 }
141 
143  int16_t *block, int n, int qscale)
144 {
145  int i, level, nCoeffs;
146  const uint16_t *quant_matrix;
147  int sum=-1;
148 
149  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
150  else qscale <<= 1;
151 
152  if(s->alternate_scan) nCoeffs= 63;
153  else nCoeffs= s->block_last_index[n];
154 
155  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
156  sum += block[0];
157  quant_matrix = s->intra_matrix;
158  for(i=1;i<=nCoeffs;i++) {
159  int j= s->intra_scantable.permutated[i];
160  level = block[j];
161  if (level) {
162  if (level < 0) {
163  level = -level;
164  level = (int)(level * qscale * quant_matrix[j]) >> 4;
165  level = -level;
166  } else {
167  level = (int)(level * qscale * quant_matrix[j]) >> 4;
168  }
169  block[j] = level;
170  sum+=level;
171  }
172  }
173  block[63]^=sum&1;
174 }
175 
177  int16_t *block, int n, int qscale)
178 {
179  int i, level, nCoeffs;
180  const uint16_t *quant_matrix;
181  int sum=-1;
182 
183  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
184  else qscale <<= 1;
185 
186  if(s->alternate_scan) nCoeffs= 63;
187  else nCoeffs= s->block_last_index[n];
188 
189  quant_matrix = s->inter_matrix;
190  for(i=0; i<=nCoeffs; i++) {
191  int j= s->intra_scantable.permutated[i];
192  level = block[j];
193  if (level) {
194  if (level < 0) {
195  level = -level;
196  level = (((level << 1) + 1) * qscale *
197  ((int) (quant_matrix[j]))) >> 5;
198  level = -level;
199  } else {
200  level = (((level << 1) + 1) * qscale *
201  ((int) (quant_matrix[j]))) >> 5;
202  }
203  block[j] = level;
204  sum+=level;
205  }
206  }
207  block[63]^=sum&1;
208 }
209 
211  int16_t *block, int n, int qscale)
212 {
213  int i, level, qmul, qadd;
214  int nCoeffs;
215 
216  av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
217 
218  qmul = qscale << 1;
219 
220  if (!s->h263_aic) {
221  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
222  qadd = (qscale - 1) | 1;
223  }else{
224  qadd = 0;
225  }
226  if(s->ac_pred)
227  nCoeffs=63;
228  else
229  nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
230 
231  for(i=1; i<=nCoeffs; i++) {
232  level = block[i];
233  if (level) {
234  if (level < 0) {
235  level = level * qmul - qadd;
236  } else {
237  level = level * qmul + qadd;
238  }
239  block[i] = level;
240  }
241  }
242 }
243 
245  int16_t *block, int n, int qscale)
246 {
247  int i, level, qmul, qadd;
248  int nCoeffs;
249 
250  av_assert2(s->block_last_index[n]>=0);
251 
252  qadd = (qscale - 1) | 1;
253  qmul = qscale << 1;
254 
255  nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
256 
257  for(i=0; i<=nCoeffs; i++) {
258  level = block[i];
259  if (level) {
260  if (level < 0) {
261  level = level * qmul - qadd;
262  } else {
263  level = level * qmul + qadd;
264  }
265  block[i] = level;
266  }
267  }
268 }
269 
270 
271 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
272 {
273  while(h--)
274  memset(dst + h*linesize, 128, 16);
275 }
276 
277 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
278 {
279  while(h--)
280  memset(dst + h*linesize, 128, 8);
281 }
282 
283 /* init common dct for both encoder and decoder */
285 {
286  ff_blockdsp_init(&s->bdsp, s->avctx);
287  ff_h264chroma_init(&s->h264chroma, 8); //for lowres
288  ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
289  ff_mpegvideodsp_init(&s->mdsp);
290  ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
291 
292  if (s->avctx->debug & FF_DEBUG_NOMC) {
293  int i;
294  for (i=0; i<4; i++) {
295  s->hdsp.avg_pixels_tab[0][i] = gray16;
296  s->hdsp.put_pixels_tab[0][i] = gray16;
297  s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
298 
299  s->hdsp.avg_pixels_tab[1][i] = gray8;
300  s->hdsp.put_pixels_tab[1][i] = gray8;
301  s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
302  }
303  }
304 
305  s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
306  s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
307  s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
308  s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
309  s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
310  if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
311  s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
312  s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
313 
316 
317  if (ARCH_ALPHA)
319  if (ARCH_ARM)
321  if (ARCH_PPC)
323  if (ARCH_X86)
325  if (ARCH_MIPS)
327 
328  return 0;
329 }
330 
332 {
333  if (s->codec_id == AV_CODEC_ID_MPEG4)
334  s->idsp.mpeg4_studio_profile = s->studio_profile;
335  ff_idctdsp_init(&s->idsp, s->avctx);
336 
337  /* load & permutate scantables
338  * note: only wmv uses different ones
339  */
340  if (s->alternate_scan) {
341  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
342  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
343  } else {
344  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
345  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
346  }
347  ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
348  ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
349 }
350 
352 {
353  return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, 0, 0,
354  s->chroma_x_shift, s->chroma_y_shift, s->out_format,
355  s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
356  &s->linesize, &s->uvlinesize);
357 }
358 
360 {
361  int y_size = s->b8_stride * (2 * s->mb_height + 1);
362  int c_size = s->mb_stride * (s->mb_height + 1);
363  int yc_size = y_size + 2 * c_size;
364  int i;
365 
366  if (s->mb_height & 1)
367  yc_size += 2*s->b8_stride + 2*s->mb_stride;
368 
369  if (s->encoding) {
370  if (!FF_ALLOCZ_TYPED_ARRAY(s->me.map, ME_MAP_SIZE) ||
371  !FF_ALLOCZ_TYPED_ARRAY(s->me.score_map, ME_MAP_SIZE))
372  return AVERROR(ENOMEM);
373 
374  if (s->noise_reduction) {
375  if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_error_sum, 2))
376  return AVERROR(ENOMEM);
377  }
378  }
379  if (!FF_ALLOCZ_TYPED_ARRAY(s->blocks, 2))
380  return AVERROR(ENOMEM);
381  s->block = s->blocks[0];
382 
383  for (i = 0; i < 12; i++) {
384  s->pblocks[i] = &s->block[i];
385  }
386 
387  if (!(s->block32 = av_mallocz(sizeof(*s->block32))) ||
388  !(s->dpcm_macroblock = av_mallocz(sizeof(*s->dpcm_macroblock))))
389  return AVERROR(ENOMEM);
390  s->dpcm_direction = 0;
391 
392  if (s->avctx->codec_tag == AV_RL32("VCR2")) {
393  // exchange uv
394  FFSWAP(void *, s->pblocks[4], s->pblocks[5]);
395  }
396 
397  if (s->out_format == FMT_H263) {
398  /* ac values */
399  if (!FF_ALLOCZ_TYPED_ARRAY(s->ac_val_base, yc_size))
400  return AVERROR(ENOMEM);
401  s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
402  s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
403  s->ac_val[2] = s->ac_val[1] + c_size;
404  }
405 
406  return 0;
407 }
408 
409 /**
410  * Initialize an MpegEncContext's thread contexts. Presumes that
411  * slice_context_count is already set and that all the fields
412  * that are freed/reset in free_duplicate_context() are NULL.
413  */
415 {
416  int nb_slices = s->slice_context_count, ret;
417 
418  /* We initialize the copies before the original so that
419  * fields allocated in init_duplicate_context are NULL after
420  * copying. This prevents double-frees upon allocation error. */
421  for (int i = 1; i < nb_slices; i++) {
422  s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
423  if (!s->thread_context[i])
424  return AVERROR(ENOMEM);
425  if ((ret = init_duplicate_context(s->thread_context[i])) < 0)
426  return ret;
427  s->thread_context[i]->start_mb_y =
428  (s->mb_height * (i ) + nb_slices / 2) / nb_slices;
429  s->thread_context[i]->end_mb_y =
430  (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
431  }
432  s->start_mb_y = 0;
433  s->end_mb_y = nb_slices > 1 ? (s->mb_height + nb_slices / 2) / nb_slices
434  : s->mb_height;
435  return init_duplicate_context(s);
436 }
437 
439 {
440  if (!s)
441  return;
442 
443  av_freep(&s->sc.edge_emu_buffer);
444  av_freep(&s->me.scratchpad);
445  s->me.temp =
446  s->sc.rd_scratchpad =
447  s->sc.b_scratchpad =
448  s->sc.obmc_scratchpad = NULL;
449 
450  av_freep(&s->dct_error_sum);
451  av_freep(&s->me.map);
452  av_freep(&s->me.score_map);
453  av_freep(&s->blocks);
454  av_freep(&s->block32);
455  av_freep(&s->dpcm_macroblock);
456  av_freep(&s->ac_val_base);
457  s->block = NULL;
458 }
459 
461 {
462  for (int i = 1; i < s->slice_context_count; i++) {
463  free_duplicate_context(s->thread_context[i]);
464  av_freep(&s->thread_context[i]);
465  }
467 }
468 
470 {
471 #define COPY(a) bak->a = src->a
472  COPY(sc.edge_emu_buffer);
473  COPY(me.scratchpad);
474  COPY(me.temp);
475  COPY(sc.rd_scratchpad);
476  COPY(sc.b_scratchpad);
477  COPY(sc.obmc_scratchpad);
478  COPY(me.map);
479  COPY(me.score_map);
480  COPY(blocks);
481  COPY(block);
482  COPY(block32);
483  COPY(dpcm_macroblock);
484  COPY(dpcm_direction);
485  COPY(start_mb_y);
486  COPY(end_mb_y);
487  COPY(me.map_generation);
488  COPY(pb);
489  COPY(dct_error_sum);
490  COPY(dct_count[0]);
491  COPY(dct_count[1]);
492  COPY(ac_val_base);
493  COPY(ac_val[0]);
494  COPY(ac_val[1]);
495  COPY(ac_val[2]);
496 #undef COPY
497 }
498 
500 {
501  MpegEncContext bak;
502  int i, ret;
503  // FIXME copy only needed parts
504  backup_duplicate_context(&bak, dst);
505  memcpy(dst, src, sizeof(MpegEncContext));
506  backup_duplicate_context(dst, &bak);
507  for (i = 0; i < 12; i++) {
508  dst->pblocks[i] = &dst->block[i];
509  }
510  if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
511  // exchange uv
512  FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]);
513  }
514  if (!dst->sc.edge_emu_buffer &&
515  (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me,
516  &dst->sc, dst->linesize)) < 0) {
517  av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
518  "scratch buffers.\n");
519  return ret;
520  }
521  return 0;
522 }
523 
525  const AVCodecContext *src)
526 {
527  int i, ret;
528  MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
529 
530  if (dst == src)
531  return 0;
532 
533  av_assert0(s != s1);
534 
535  // FIXME can parameters change on I-frames?
536  // in that case dst may need a reinit
537  if (!s->context_initialized) {
538  int err;
539  memcpy(s, s1, sizeof(MpegEncContext));
540 
541  s->avctx = dst;
542  s->bitstream_buffer = NULL;
543  s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
544 
545  if (s1->context_initialized){
546 // s->picture_range_start += MAX_PICTURE_COUNT;
547 // s->picture_range_end += MAX_PICTURE_COUNT;
549  if((err = ff_mpv_common_init(s)) < 0){
550  memset(s, 0, sizeof(MpegEncContext));
551  s->avctx = dst;
552  return err;
553  }
554  }
555  }
556 
557  if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
558  s->height = s1->height;
559  s->width = s1->width;
560  if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
561  return ret;
562  }
563 
564  s->avctx->coded_height = s1->avctx->coded_height;
565  s->avctx->coded_width = s1->avctx->coded_width;
566  s->avctx->width = s1->avctx->width;
567  s->avctx->height = s1->avctx->height;
568 
569  s->quarter_sample = s1->quarter_sample;
570 
571  s->coded_picture_number = s1->coded_picture_number;
572  s->picture_number = s1->picture_number;
573 
574  av_assert0(!s->picture || s->picture != s1->picture);
575  if(s->picture)
576  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
577  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
578  if (s1->picture && s1->picture[i].f->buf[0] &&
579  (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
580  return ret;
581  }
582 
583 #define UPDATE_PICTURE(pic)\
584 do {\
585  ff_mpeg_unref_picture(s->avctx, &s->pic);\
586  if (s1->pic.f && s1->pic.f->buf[0])\
587  ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
588  else\
589  ret = ff_update_picture_tables(&s->pic, &s1->pic);\
590  if (ret < 0)\
591  return ret;\
592 } while (0)
593 
594  UPDATE_PICTURE(current_picture);
596  UPDATE_PICTURE(next_picture);
597 
598 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
599  ((pic && pic >= old_ctx->picture && \
600  pic < old_ctx->picture + MAX_PICTURE_COUNT) ? \
601  &new_ctx->picture[pic - old_ctx->picture] : NULL)
602 
603  s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
604  s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
605  s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
606 
607  // Error/bug resilience
608  s->next_p_frame_damaged = s1->next_p_frame_damaged;
609  s->workaround_bugs = s1->workaround_bugs;
610  s->padding_bug_score = s1->padding_bug_score;
611 
612  // MPEG-4 timing info
613  memcpy(&s->last_time_base, &s1->last_time_base,
614  (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
615  (char *) &s1->last_time_base);
616 
617  // B-frame info
618  s->max_b_frames = s1->max_b_frames;
619  s->low_delay = s1->low_delay;
620  s->droppable = s1->droppable;
621 
622  // DivX handling (doesn't work)
623  s->divx_packed = s1->divx_packed;
624 
625  if (s1->bitstream_buffer) {
626  if (s1->bitstream_buffer_size +
627  AV_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size) {
628  av_fast_malloc(&s->bitstream_buffer,
629  &s->allocated_bitstream_buffer_size,
630  s1->allocated_bitstream_buffer_size);
631  if (!s->bitstream_buffer) {
632  s->bitstream_buffer_size = 0;
633  return AVERROR(ENOMEM);
634  }
635  }
636  s->bitstream_buffer_size = s1->bitstream_buffer_size;
637  memcpy(s->bitstream_buffer, s1->bitstream_buffer,
638  s1->bitstream_buffer_size);
639  memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
641  }
642 
643  // linesize-dependent scratch buffer allocation
644  if (!s->sc.edge_emu_buffer)
645  if (s1->linesize) {
646  if (ff_mpeg_framesize_alloc(s->avctx, &s->me,
647  &s->sc, s1->linesize) < 0) {
648  av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
649  "scratch buffers.\n");
650  return AVERROR(ENOMEM);
651  }
652  } else {
653  av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
654  "be allocated due to unknown size.\n");
655  }
656 
657  // MPEG-2/interlacing info
658  memcpy(&s->progressive_sequence, &s1->progressive_sequence,
659  (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
660 
661  if (!s1->first_field) {
662  s->last_pict_type = s1->pict_type;
663  if (s1->current_picture_ptr)
664  s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
665  }
666 
667  return 0;
668 }
669 
670 /**
671  * Set the given MpegEncContext to common defaults
672  * (same for encoding and decoding).
673  * The changed fields will not depend upon the
674  * prior state of the MpegEncContext.
675  */
677 {
678  s->y_dc_scale_table =
679  s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
680  s->chroma_qscale_table = ff_default_chroma_qscale_table;
681  s->progressive_frame = 1;
682  s->progressive_sequence = 1;
683  s->picture_structure = PICT_FRAME;
684 
685  s->coded_picture_number = 0;
686  s->picture_number = 0;
687 
688  s->f_code = 1;
689  s->b_code = 1;
690 
691  s->slice_context_count = 1;
692 }
693 
694 /**
695  * Initialize the given MpegEncContext for decoding.
696  * the changed fields will not depend upon
697  * the prior state of the MpegEncContext.
698  */
700 {
702 
703  s->avctx = avctx;
704  s->width = avctx->coded_width;
705  s->height = avctx->coded_height;
706  s->codec_id = avctx->codec->id;
707  s->workaround_bugs = avctx->workaround_bugs;
708 
709  /* convert fourcc to upper case */
710  s->codec_tag = avpriv_toupper4(avctx->codec_tag);
711 }
712 
713 /**
714  * Initialize and allocates MpegEncContext fields dependent on the resolution.
715  */
717 {
718  int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
719 
720  s->mb_width = (s->width + 15) / 16;
721  s->mb_stride = s->mb_width + 1;
722  s->b8_stride = s->mb_width * 2 + 1;
723  mb_array_size = s->mb_height * s->mb_stride;
724  mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
725 
726  /* set default edge pos, will be overridden
727  * in decode_header if needed */
728  s->h_edge_pos = s->mb_width * 16;
729  s->v_edge_pos = s->mb_height * 16;
730 
731  s->mb_num = s->mb_width * s->mb_height;
732 
733  s->block_wrap[0] =
734  s->block_wrap[1] =
735  s->block_wrap[2] =
736  s->block_wrap[3] = s->b8_stride;
737  s->block_wrap[4] =
738  s->block_wrap[5] = s->mb_stride;
739 
740  y_size = s->b8_stride * (2 * s->mb_height + 1);
741  c_size = s->mb_stride * (s->mb_height + 1);
742  yc_size = y_size + 2 * c_size;
743 
744  if (s->mb_height & 1)
745  yc_size += 2*s->b8_stride + 2*s->mb_stride;
746 
747  if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_index2xy, s->mb_num + 1))
748  return AVERROR(ENOMEM);
749  for (y = 0; y < s->mb_height; y++)
750  for (x = 0; x < s->mb_width; x++)
751  s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
752 
753  s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
754 
755  if (s->encoding) {
756  /* Allocate MV tables */
757  if (!FF_ALLOCZ_TYPED_ARRAY(s->p_mv_table_base, mv_table_size) ||
758  !FF_ALLOCZ_TYPED_ARRAY(s->b_forw_mv_table_base, mv_table_size) ||
759  !FF_ALLOCZ_TYPED_ARRAY(s->b_back_mv_table_base, mv_table_size) ||
760  !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_forw_mv_table_base, mv_table_size) ||
761  !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_back_mv_table_base, mv_table_size) ||
762  !FF_ALLOCZ_TYPED_ARRAY(s->b_direct_mv_table_base, mv_table_size))
763  return AVERROR(ENOMEM);
764  s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
765  s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
766  s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
767  s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
768  s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
769  s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
770 
771  /* Allocate MB type table */
772  if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_type, mb_array_size) ||
773  !FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size) ||
774  !FF_ALLOC_TYPED_ARRAY (s->cplx_tab, mb_array_size) ||
775  !FF_ALLOC_TYPED_ARRAY (s->bits_tab, mb_array_size))
776  return AVERROR(ENOMEM);
777  }
778 
779  if (s->codec_id == AV_CODEC_ID_MPEG4 ||
780  (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
781  /* interlaced direct mode decoding tables */
782  for (i = 0; i < 2; i++) {
783  int j, k;
784  for (j = 0; j < 2; j++) {
785  for (k = 0; k < 2; k++) {
786  if (!FF_ALLOCZ_TYPED_ARRAY(s->b_field_mv_table_base[i][j][k], mv_table_size))
787  return AVERROR(ENOMEM);
788  s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
789  s->mb_stride + 1;
790  }
791  if (!FF_ALLOCZ_TYPED_ARRAY(s->b_field_select_table [i][j], mv_table_size * 2) ||
792  !FF_ALLOCZ_TYPED_ARRAY(s->p_field_mv_table_base[i][j], mv_table_size))
793  return AVERROR(ENOMEM);
794  s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
795  }
796  if (!FF_ALLOCZ_TYPED_ARRAY(s->p_field_select_table[i], mv_table_size * 2))
797  return AVERROR(ENOMEM);
798  }
799  }
800  if (s->out_format == FMT_H263) {
801  /* cbp values, cbp, ac_pred, pred_dir */
802  if (!FF_ALLOCZ_TYPED_ARRAY(s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride) ||
803  !FF_ALLOCZ_TYPED_ARRAY(s->cbp_table, mb_array_size) ||
804  !FF_ALLOCZ_TYPED_ARRAY(s->pred_dir_table, mb_array_size))
805  return AVERROR(ENOMEM);
806  s->coded_block = s->coded_block_base + s->b8_stride + 1;
807  }
808 
809  if (s->h263_pred || s->h263_plus || !s->encoding) {
810  /* dc values */
811  // MN: we need these for error resilience of intra-frames
812  if (!FF_ALLOCZ_TYPED_ARRAY(s->dc_val_base, yc_size))
813  return AVERROR(ENOMEM);
814  s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
815  s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
816  s->dc_val[2] = s->dc_val[1] + c_size;
817  for (i = 0; i < yc_size; i++)
818  s->dc_val_base[i] = 1024;
819  }
820 
821  /* which mb is an intra block, init macroblock skip table */
822  if (!FF_ALLOC_TYPED_ARRAY(s->mbintra_table, mb_array_size) ||
823  // Note the + 1 is for a quicker MPEG-4 slice_end detection
824  !FF_ALLOCZ_TYPED_ARRAY(s->mbskip_table, mb_array_size + 2))
825  return AVERROR(ENOMEM);
826  memset(s->mbintra_table, 1, mb_array_size);
827 
828  return ff_mpeg_er_init(s);
829 }
830 
832 {
833  int i, j, k;
834 
835  memset(&s->next_picture, 0, sizeof(s->next_picture));
836  memset(&s->last_picture, 0, sizeof(s->last_picture));
837  memset(&s->current_picture, 0, sizeof(s->current_picture));
838  memset(&s->new_picture, 0, sizeof(s->new_picture));
839 
840  memset(s->thread_context, 0, sizeof(s->thread_context));
841 
842  s->me.map = NULL;
843  s->me.score_map = NULL;
844  s->dct_error_sum = NULL;
845  s->block = NULL;
846  s->blocks = NULL;
847  s->block32 = NULL;
848  memset(s->pblocks, 0, sizeof(s->pblocks));
849  s->dpcm_direction = 0;
850  s->dpcm_macroblock = NULL;
851  s->ac_val_base = NULL;
852  s->ac_val[0] =
853  s->ac_val[1] =
854  s->ac_val[2] =NULL;
855  s->sc.edge_emu_buffer = NULL;
856  s->me.scratchpad = NULL;
857  s->me.temp =
858  s->sc.rd_scratchpad =
859  s->sc.b_scratchpad =
860  s->sc.obmc_scratchpad = NULL;
861 
862 
863  s->bitstream_buffer = NULL;
864  s->allocated_bitstream_buffer_size = 0;
865  s->picture = NULL;
866  s->mb_type = NULL;
867  s->p_mv_table_base = NULL;
868  s->b_forw_mv_table_base = NULL;
869  s->b_back_mv_table_base = NULL;
870  s->b_bidir_forw_mv_table_base = NULL;
871  s->b_bidir_back_mv_table_base = NULL;
872  s->b_direct_mv_table_base = NULL;
873  s->p_mv_table = NULL;
874  s->b_forw_mv_table = NULL;
875  s->b_back_mv_table = NULL;
876  s->b_bidir_forw_mv_table = NULL;
877  s->b_bidir_back_mv_table = NULL;
878  s->b_direct_mv_table = NULL;
879  for (i = 0; i < 2; i++) {
880  for (j = 0; j < 2; j++) {
881  for (k = 0; k < 2; k++) {
882  s->b_field_mv_table_base[i][j][k] = NULL;
883  s->b_field_mv_table[i][j][k] = NULL;
884  }
885  s->b_field_select_table[i][j] = NULL;
886  s->p_field_mv_table_base[i][j] = NULL;
887  s->p_field_mv_table[i][j] = NULL;
888  }
889  s->p_field_select_table[i] = NULL;
890  }
891 
892  s->dc_val_base = NULL;
893  s->coded_block_base = NULL;
894  s->mbintra_table = NULL;
895  s->cbp_table = NULL;
896  s->pred_dir_table = NULL;
897 
898  s->mbskip_table = NULL;
899 
900  s->er.error_status_table = NULL;
901  s->er.er_temp_buffer = NULL;
902  s->mb_index2xy = NULL;
903  s->lambda_table = NULL;
904 
905  s->cplx_tab = NULL;
906  s->bits_tab = NULL;
907 }
908 
909 /**
910  * init common structure for both encoder and decoder.
911  * this assumes that some variables like width/height are already set
912  */
914 {
915  int i, ret;
916  int nb_slices = (HAVE_THREADS &&
917  s->avctx->active_thread_type & FF_THREAD_SLICE) ?
918  s->avctx->thread_count : 1;
919 
920  clear_context(s);
921 
922  if (s->encoding && s->avctx->slices)
923  nb_slices = s->avctx->slices;
924 
925  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
926  s->mb_height = (s->height + 31) / 32 * 2;
927  else
928  s->mb_height = (s->height + 15) / 16;
929 
930  if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
931  av_log(s->avctx, AV_LOG_ERROR,
932  "decoding to AV_PIX_FMT_NONE is not supported.\n");
933  return AVERROR(EINVAL);
934  }
935 
936  if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
937  int max_slices;
938  if (s->mb_height)
939  max_slices = FFMIN(MAX_THREADS, s->mb_height);
940  else
941  max_slices = MAX_THREADS;
942  av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
943  " reducing to %d\n", nb_slices, max_slices);
944  nb_slices = max_slices;
945  }
946 
947  if ((s->width || s->height) &&
948  av_image_check_size(s->width, s->height, 0, s->avctx))
949  return AVERROR(EINVAL);
950 
951  dct_init(s);
952 
953  /* set chroma shifts */
954  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
955  &s->chroma_x_shift,
956  &s->chroma_y_shift);
957  if (ret)
958  return ret;
959 
960  if (!FF_ALLOCZ_TYPED_ARRAY(s->picture, MAX_PICTURE_COUNT))
961  return AVERROR(ENOMEM);
962  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
963  s->picture[i].f = av_frame_alloc();
964  if (!s->picture[i].f)
965  goto fail_nomem;
966  }
967 
968  if (!(s->next_picture.f = av_frame_alloc()) ||
969  !(s->last_picture.f = av_frame_alloc()) ||
970  !(s->current_picture.f = av_frame_alloc()) ||
971  !(s->new_picture.f = av_frame_alloc()))
972  goto fail_nomem;
973 
974  if ((ret = init_context_frame(s)))
975  goto fail;
976 
977  s->parse_context.state = -1;
978 
979  s->context_initialized = 1;
980  memset(s->thread_context, 0, sizeof(s->thread_context));
981  s->thread_context[0] = s;
982  s->slice_context_count = nb_slices;
983 
984 // if (s->width && s->height) {
985  ret = init_duplicate_contexts(s);
986  if (ret < 0)
987  goto fail;
988 // }
989 
990  return 0;
991  fail_nomem:
992  ret = AVERROR(ENOMEM);
993  fail:
995  return ret;
996 }
997 
998 /**
999  * Frees and resets MpegEncContext fields depending on the resolution
1000  * as well as the slice thread contexts.
1001  * Is used during resolution changes to avoid a full reinitialization of the
1002  * codec.
1003  */
1005 {
1006  int i, j, k;
1007 
1009 
1010  av_freep(&s->mb_type);
1011  av_freep(&s->p_mv_table_base);
1012  av_freep(&s->b_forw_mv_table_base);
1013  av_freep(&s->b_back_mv_table_base);
1014  av_freep(&s->b_bidir_forw_mv_table_base);
1015  av_freep(&s->b_bidir_back_mv_table_base);
1016  av_freep(&s->b_direct_mv_table_base);
1017  s->p_mv_table = NULL;
1018  s->b_forw_mv_table = NULL;
1019  s->b_back_mv_table = NULL;
1020  s->b_bidir_forw_mv_table = NULL;
1021  s->b_bidir_back_mv_table = NULL;
1022  s->b_direct_mv_table = NULL;
1023  for (i = 0; i < 2; i++) {
1024  for (j = 0; j < 2; j++) {
1025  for (k = 0; k < 2; k++) {
1026  av_freep(&s->b_field_mv_table_base[i][j][k]);
1027  s->b_field_mv_table[i][j][k] = NULL;
1028  }
1029  av_freep(&s->b_field_select_table[i][j]);
1030  av_freep(&s->p_field_mv_table_base[i][j]);
1031  s->p_field_mv_table[i][j] = NULL;
1032  }
1033  av_freep(&s->p_field_select_table[i]);
1034  }
1035 
1036  av_freep(&s->dc_val_base);
1037  av_freep(&s->coded_block_base);
1038  av_freep(&s->mbintra_table);
1039  av_freep(&s->cbp_table);
1040  av_freep(&s->pred_dir_table);
1041 
1042  av_freep(&s->mbskip_table);
1043 
1044  av_freep(&s->er.error_status_table);
1045  av_freep(&s->er.er_temp_buffer);
1046  av_freep(&s->mb_index2xy);
1047  av_freep(&s->lambda_table);
1048 
1049  av_freep(&s->cplx_tab);
1050  av_freep(&s->bits_tab);
1051 
1052  s->linesize = s->uvlinesize = 0;
1053 }
1054 
1056 {
1057  int i, err = 0;
1058 
1059  if (!s->context_initialized)
1060  return AVERROR(EINVAL);
1061 
1063 
1064  if (s->picture)
1065  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1066  s->picture[i].needs_realloc = 1;
1067  }
1068 
1069  s->last_picture_ptr =
1070  s->next_picture_ptr =
1071  s->current_picture_ptr = NULL;
1072 
1073  // init
1074  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1075  s->mb_height = (s->height + 31) / 32 * 2;
1076  else
1077  s->mb_height = (s->height + 15) / 16;
1078 
1079  if ((s->width || s->height) &&
1080  (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1081  goto fail;
1082 
1083  /* set chroma shifts */
1084  err = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1085  &s->chroma_x_shift,
1086  &s->chroma_y_shift);
1087  if (err < 0)
1088  goto fail;
1089 
1090  if ((err = init_context_frame(s)))
1091  goto fail;
1092 
1093  memset(s->thread_context, 0, sizeof(s->thread_context));
1094  s->thread_context[0] = s;
1095 
1096  if (s->width && s->height) {
1097  err = init_duplicate_contexts(s);
1098  if (err < 0)
1099  goto fail;
1100  }
1101  s->context_reinit = 0;
1102 
1103  return 0;
1104  fail:
1106  s->context_reinit = 1;
1107  return err;
1108 }
1109 
1110 /* init common structure for both encoder and decoder */
1112 {
1113  int i;
1114 
1115  if (!s)
1116  return;
1117 
1119  if (s->slice_context_count > 1)
1120  s->slice_context_count = 1;
1121 
1122  av_freep(&s->parse_context.buffer);
1123  s->parse_context.buffer_size = 0;
1124 
1125  av_freep(&s->bitstream_buffer);
1126  s->allocated_bitstream_buffer_size = 0;
1127 
1128  if (!s->avctx)
1129  return;
1130 
1131  if (s->picture) {
1132  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1133  ff_free_picture_tables(&s->picture[i]);
1134  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1135  av_frame_free(&s->picture[i].f);
1136  }
1137  }
1138  av_freep(&s->picture);
1139  ff_free_picture_tables(&s->last_picture);
1140  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1141  av_frame_free(&s->last_picture.f);
1142  ff_free_picture_tables(&s->current_picture);
1143  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1144  av_frame_free(&s->current_picture.f);
1145  ff_free_picture_tables(&s->next_picture);
1146  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1147  av_frame_free(&s->next_picture.f);
1148  ff_free_picture_tables(&s->new_picture);
1149  ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1150  av_frame_free(&s->new_picture.f);
1151 
1152  s->context_initialized = 0;
1153  s->context_reinit = 0;
1154  s->last_picture_ptr =
1155  s->next_picture_ptr =
1156  s->current_picture_ptr = NULL;
1157  s->linesize = s->uvlinesize = 0;
1158 }
1159 
1160 
1161 static void gray_frame(AVFrame *frame)
1162 {
1163  int i, h_chroma_shift, v_chroma_shift;
1164 
1165  av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1166 
1167  for(i=0; i<frame->height; i++)
1168  memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1169  for(i=0; i<AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1170  memset(frame->data[1] + frame->linesize[1]*i,
1171  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1172  memset(frame->data[2] + frame->linesize[2]*i,
1173  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1174  }
1175 }
1176 
1177 /**
1178  * generic function called after decoding
1179  * the header and before a frame is decoded.
1180  */
1182 {
1183  int i, ret;
1184  Picture *pic;
1185  s->mb_skipped = 0;
1186 
1187  if (!ff_thread_can_start_frame(avctx)) {
1188  av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1189  return -1;
1190  }
1191 
1192  /* mark & release old frames */
1193  if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1194  s->last_picture_ptr != s->next_picture_ptr &&
1195  s->last_picture_ptr->f->buf[0]) {
1196  ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1197  }
1198 
1199  /* release forgotten pictures */
1200  /* if (MPEG-124 / H.263) */
1201  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1202  if (&s->picture[i] != s->last_picture_ptr &&
1203  &s->picture[i] != s->next_picture_ptr &&
1204  s->picture[i].reference && !s->picture[i].needs_realloc) {
1205  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1206  }
1207  }
1208 
1209  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1210  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1211  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1212 
1213  /* release non reference frames */
1214  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1215  if (!s->picture[i].reference)
1216  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1217  }
1218 
1219  if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1220  // we already have an unused image
1221  // (maybe it was set before reading the header)
1222  pic = s->current_picture_ptr;
1223  } else {
1224  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1225  if (i < 0) {
1226  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1227  return i;
1228  }
1229  pic = &s->picture[i];
1230  }
1231 
1232  pic->reference = 0;
1233  if (!s->droppable) {
1234  if (s->pict_type != AV_PICTURE_TYPE_B)
1235  pic->reference = 3;
1236  }
1237 
1238  pic->f->coded_picture_number = s->coded_picture_number++;
1239 
1240  if (alloc_picture(s, pic) < 0)
1241  return -1;
1242 
1243  s->current_picture_ptr = pic;
1244  // FIXME use only the vars from current_pic
1245  s->current_picture_ptr->f->top_field_first = s->top_field_first;
1246  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1247  s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1248  if (s->picture_structure != PICT_FRAME)
1249  s->current_picture_ptr->f->top_field_first =
1250  (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1251  }
1252  s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1253  !s->progressive_sequence;
1254  s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1255 
1256  s->current_picture_ptr->f->pict_type = s->pict_type;
1257  // if (s->avctx->flags && AV_CODEC_FLAG_QSCALE)
1258  // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1259  s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1260 
1261  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1262  s->current_picture_ptr)) < 0)
1263  return ret;
1264 
1265  if (s->pict_type != AV_PICTURE_TYPE_B) {
1266  s->last_picture_ptr = s->next_picture_ptr;
1267  if (!s->droppable)
1268  s->next_picture_ptr = s->current_picture_ptr;
1269  }
1270  ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1271  s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1272  s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
1273  s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
1274  s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1275  s->pict_type, s->droppable);
1276 
1277  if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1278  (s->pict_type != AV_PICTURE_TYPE_I)) {
1279  int h_chroma_shift, v_chroma_shift;
1280  av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1281  &h_chroma_shift, &v_chroma_shift);
1282  if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1283  av_log(avctx, AV_LOG_DEBUG,
1284  "allocating dummy last picture for B frame\n");
1285  else if (s->pict_type != AV_PICTURE_TYPE_I)
1286  av_log(avctx, AV_LOG_ERROR,
1287  "warning: first frame is no keyframe\n");
1288 
1289  /* Allocate a dummy frame */
1290  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1291  if (i < 0) {
1292  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1293  return i;
1294  }
1295  s->last_picture_ptr = &s->picture[i];
1296 
1297  s->last_picture_ptr->reference = 3;
1298  s->last_picture_ptr->f->key_frame = 0;
1299  s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1300 
1301  if (alloc_picture(s, s->last_picture_ptr) < 0) {
1302  s->last_picture_ptr = NULL;
1303  return -1;
1304  }
1305 
1306  if (!avctx->hwaccel) {
1307  for(i=0; i<avctx->height; i++)
1308  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1309  0x80, avctx->width);
1310  if (s->last_picture_ptr->f->data[2]) {
1311  for(i=0; i<AV_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1312  memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1313  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1314  memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1315  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1316  }
1317  }
1318 
1319  if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1320  for(i=0; i<avctx->height; i++)
1321  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1322  }
1323  }
1324 
1325  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1326  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1327  }
1328  if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1329  s->pict_type == AV_PICTURE_TYPE_B) {
1330  /* Allocate a dummy frame */
1331  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1332  if (i < 0) {
1333  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1334  return i;
1335  }
1336  s->next_picture_ptr = &s->picture[i];
1337 
1338  s->next_picture_ptr->reference = 3;
1339  s->next_picture_ptr->f->key_frame = 0;
1340  s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1341 
1342  if (alloc_picture(s, s->next_picture_ptr) < 0) {
1343  s->next_picture_ptr = NULL;
1344  return -1;
1345  }
1346  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1347  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1348  }
1349 
1350 #if 0 // BUFREF-FIXME
1351  memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1352  memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1353 #endif
1354  if (s->last_picture_ptr) {
1355  if (s->last_picture_ptr->f->buf[0] &&
1356  (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1357  s->last_picture_ptr)) < 0)
1358  return ret;
1359  }
1360  if (s->next_picture_ptr) {
1361  if (s->next_picture_ptr->f->buf[0] &&
1362  (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1363  s->next_picture_ptr)) < 0)
1364  return ret;
1365  }
1366 
1367  av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1368  s->last_picture_ptr->f->buf[0]));
1369 
1370  if (s->picture_structure!= PICT_FRAME) {
1371  int i;
1372  for (i = 0; i < 4; i++) {
1373  if (s->picture_structure == PICT_BOTTOM_FIELD) {
1374  s->current_picture.f->data[i] +=
1375  s->current_picture.f->linesize[i];
1376  }
1377  s->current_picture.f->linesize[i] *= 2;
1378  s->last_picture.f->linesize[i] *= 2;
1379  s->next_picture.f->linesize[i] *= 2;
1380  }
1381  }
1382 
1383  /* set dequantizer, we can't do it during init as
1384  * it might change for MPEG-4 and we can't do it in the header
1385  * decode as init is not called for MPEG-4 there yet */
1386  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1387  s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1388  s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1389  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1390  s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1391  s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1392  } else {
1393  s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1394  s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1395  }
1396 
1397  if (s->avctx->debug & FF_DEBUG_NOMC) {
1398  gray_frame(s->current_picture_ptr->f);
1399  }
1400 
1401  return 0;
1402 }
1403 
1404 /* called after a frame has been decoded. */
1406 {
1407  emms_c();
1408 
1409  if (s->current_picture.reference)
1410  ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1411 }
1412 
1414 {
1415  ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
1416  p->qscale_table, p->motion_val, &s->low_delay,
1417  s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
1418 }
1419 
1421 {
1422  AVVideoEncParams *par;
1423  int mult = (qp_type == FF_QSCALE_TYPE_MPEG1) ? 2 : 1;
1424  unsigned int nb_mb = p->alloc_mb_height * p->alloc_mb_width;
1425  unsigned int x, y;
1426 
1427  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS))
1428  return 0;
1429 
1431  if (!par)
1432  return AVERROR(ENOMEM);
1433 
1434  for (y = 0; y < p->alloc_mb_height; y++)
1435  for (x = 0; x < p->alloc_mb_width; x++) {
1436  const unsigned int block_idx = y * p->alloc_mb_width + x;
1437  const unsigned int mb_xy = y * p->alloc_mb_stride + x;
1438  AVVideoBlockParams *b = av_video_enc_params_block(par, block_idx);
1439 
1440  b->src_x = x * 16;
1441  b->src_y = y * 16;
1442  b->w = 16;
1443  b->h = 16;
1444 
1445  b->delta_qp = p->qscale_table[mb_xy] * mult;
1446  }
1447 
1448  return 0;
1449 }
1450 
1452  uint8_t *dest, uint8_t *src,
1453  int field_based, int field_select,
1454  int src_x, int src_y,
1455  int width, int height, ptrdiff_t stride,
1456  int h_edge_pos, int v_edge_pos,
1457  int w, int h, h264_chroma_mc_func *pix_op,
1458  int motion_x, int motion_y)
1459 {
1460  const int lowres = s->avctx->lowres;
1461  const int op_index = FFMIN(lowres, 3);
1462  const int s_mask = (2 << lowres) - 1;
1463  int emu = 0;
1464  int sx, sy;
1465 
1466  if (s->quarter_sample) {
1467  motion_x /= 2;
1468  motion_y /= 2;
1469  }
1470 
1471  sx = motion_x & s_mask;
1472  sy = motion_y & s_mask;
1473  src_x += motion_x >> lowres + 1;
1474  src_y += motion_y >> lowres + 1;
1475 
1476  src += src_y * stride + src_x;
1477 
1478  if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1479  (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1480  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, src,
1481  s->linesize, s->linesize,
1482  w + 1, (h + 1) << field_based,
1483  src_x, src_y << field_based,
1484  h_edge_pos, v_edge_pos);
1485  src = s->sc.edge_emu_buffer;
1486  emu = 1;
1487  }
1488 
1489  sx = (sx << 2) >> lowres;
1490  sy = (sy << 2) >> lowres;
1491  if (field_select)
1492  src += s->linesize;
1493  pix_op[op_index](dest, src, stride, h, sx, sy);
1494  return emu;
1495 }
1496 
1497 /* apply one mpeg motion vector to the three components */
1499  uint8_t *dest_y,
1500  uint8_t *dest_cb,
1501  uint8_t *dest_cr,
1502  int field_based,
1503  int bottom_field,
1504  int field_select,
1505  uint8_t **ref_picture,
1506  h264_chroma_mc_func *pix_op,
1507  int motion_x, int motion_y,
1508  int h, int mb_y)
1509 {
1510  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1511  int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
1512  ptrdiff_t uvlinesize, linesize;
1513  const int lowres = s->avctx->lowres;
1514  const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3);
1515  const int block_s = 8>>lowres;
1516  const int s_mask = (2 << lowres) - 1;
1517  const int h_edge_pos = s->h_edge_pos >> lowres;
1518  const int v_edge_pos = s->v_edge_pos >> lowres;
1519  linesize = s->current_picture.f->linesize[0] << field_based;
1520  uvlinesize = s->current_picture.f->linesize[1] << field_based;
1521 
1522  // FIXME obviously not perfect but qpel will not work in lowres anyway
1523  if (s->quarter_sample) {
1524  motion_x /= 2;
1525  motion_y /= 2;
1526  }
1527 
1528  if(field_based){
1529  motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1530  }
1531 
1532  sx = motion_x & s_mask;
1533  sy = motion_y & s_mask;
1534  src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1535  src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1536 
1537  if (s->out_format == FMT_H263) {
1538  uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1539  uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1540  uvsrc_x = src_x >> 1;
1541  uvsrc_y = src_y >> 1;
1542  } else if (s->out_format == FMT_H261) {
1543  // even chroma mv's are full pel in H261
1544  mx = motion_x / 4;
1545  my = motion_y / 4;
1546  uvsx = (2 * mx) & s_mask;
1547  uvsy = (2 * my) & s_mask;
1548  uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1549  uvsrc_y = mb_y * block_s + (my >> lowres);
1550  } else {
1551  if(s->chroma_y_shift){
1552  mx = motion_x / 2;
1553  my = motion_y / 2;
1554  uvsx = mx & s_mask;
1555  uvsy = my & s_mask;
1556  uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1557  uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1558  } else {
1559  if(s->chroma_x_shift){
1560  //Chroma422
1561  mx = motion_x / 2;
1562  uvsx = mx & s_mask;
1563  uvsy = motion_y & s_mask;
1564  uvsrc_y = src_y;
1565  uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1566  } else {
1567  //Chroma444
1568  uvsx = motion_x & s_mask;
1569  uvsy = motion_y & s_mask;
1570  uvsrc_x = src_x;
1571  uvsrc_y = src_y;
1572  }
1573  }
1574  }
1575 
1576  ptr_y = ref_picture[0] + src_y * linesize + src_x;
1577  ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1578  ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1579 
1580  if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
1581  (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1582  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
1583  linesize >> field_based, linesize >> field_based,
1584  17, 17 + field_based,
1585  src_x, src_y << field_based, h_edge_pos,
1586  v_edge_pos);
1587  ptr_y = s->sc.edge_emu_buffer;
1588  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1589  uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
1590  uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
1591  if (s->workaround_bugs & FF_BUG_IEDGE)
1592  vbuf -= s->uvlinesize;
1593  s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
1594  uvlinesize >> field_based, uvlinesize >> field_based,
1595  9, 9 + field_based,
1596  uvsrc_x, uvsrc_y << field_based,
1597  h_edge_pos >> 1, v_edge_pos >> 1);
1598  s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
1599  uvlinesize >> field_based,uvlinesize >> field_based,
1600  9, 9 + field_based,
1601  uvsrc_x, uvsrc_y << field_based,
1602  h_edge_pos >> 1, v_edge_pos >> 1);
1603  ptr_cb = ubuf;
1604  ptr_cr = vbuf;
1605  }
1606  }
1607 
1608  // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
1609  if (bottom_field) {
1610  dest_y += s->linesize;
1611  dest_cb += s->uvlinesize;
1612  dest_cr += s->uvlinesize;
1613  }
1614 
1615  if (field_select) {
1616  ptr_y += s->linesize;
1617  ptr_cb += s->uvlinesize;
1618  ptr_cr += s->uvlinesize;
1619  }
1620 
1621  sx = (sx << 2) >> lowres;
1622  sy = (sy << 2) >> lowres;
1623  pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1624 
1625  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1626  int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
1627  uvsx = (uvsx << 2) >> lowres;
1628  uvsy = (uvsy << 2) >> lowres;
1629  if (hc) {
1630  pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
1631  pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
1632  }
1633  }
1634  // FIXME h261 lowres loop filter
1635 }
1636 
1638  uint8_t *dest_cb, uint8_t *dest_cr,
1639  uint8_t **ref_picture,
1640  h264_chroma_mc_func * pix_op,
1641  int mx, int my)
1642 {
1643  const int lowres = s->avctx->lowres;
1644  const int op_index = FFMIN(lowres, 3);
1645  const int block_s = 8 >> lowres;
1646  const int s_mask = (2 << lowres) - 1;
1647  const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1648  const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1649  int emu = 0, src_x, src_y, sx, sy;
1650  ptrdiff_t offset;
1651  uint8_t *ptr;
1652 
1653  if (s->quarter_sample) {
1654  mx /= 2;
1655  my /= 2;
1656  }
1657 
1658  /* In case of 8X8, we construct a single chroma motion vector
1659  with a special rounding */
1660  mx = ff_h263_round_chroma(mx);
1661  my = ff_h263_round_chroma(my);
1662 
1663  sx = mx & s_mask;
1664  sy = my & s_mask;
1665  src_x = s->mb_x * block_s + (mx >> lowres + 1);
1666  src_y = s->mb_y * block_s + (my >> lowres + 1);
1667 
1668  offset = src_y * s->uvlinesize + src_x;
1669  ptr = ref_picture[1] + offset;
1670  if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1671  (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1672  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1673  s->uvlinesize, s->uvlinesize,
1674  9, 9,
1675  src_x, src_y, h_edge_pos, v_edge_pos);
1676  ptr = s->sc.edge_emu_buffer;
1677  emu = 1;
1678  }
1679  sx = (sx << 2) >> lowres;
1680  sy = (sy << 2) >> lowres;
1681  pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1682 
1683  ptr = ref_picture[2] + offset;
1684  if (emu) {
1685  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1686  s->uvlinesize, s->uvlinesize,
1687  9, 9,
1688  src_x, src_y, h_edge_pos, v_edge_pos);
1689  ptr = s->sc.edge_emu_buffer;
1690  }
1691  pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1692 }
1693 
1694 /**
1695  * motion compensation of a single macroblock
1696  * @param s context
1697  * @param dest_y luma destination pointer
1698  * @param dest_cb chroma cb/u destination pointer
1699  * @param dest_cr chroma cr/v destination pointer
1700  * @param dir direction (0->forward, 1->backward)
1701  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1702  * @param pix_op halfpel motion compensation function (average or put normally)
1703  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1704  */
1705 static inline void MPV_motion_lowres(MpegEncContext *s,
1706  uint8_t *dest_y, uint8_t *dest_cb,
1707  uint8_t *dest_cr,
1708  int dir, uint8_t **ref_picture,
1709  h264_chroma_mc_func *pix_op)
1710 {
1711  int mx, my;
1712  int mb_x, mb_y, i;
1713  const int lowres = s->avctx->lowres;
1714  const int block_s = 8 >>lowres;
1715 
1716  mb_x = s->mb_x;
1717  mb_y = s->mb_y;
1718 
1719  switch (s->mv_type) {
1720  case MV_TYPE_16X16:
1721  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1722  0, 0, 0,
1723  ref_picture, pix_op,
1724  s->mv[dir][0][0], s->mv[dir][0][1],
1725  2 * block_s, mb_y);
1726  break;
1727  case MV_TYPE_8X8:
1728  mx = 0;
1729  my = 0;
1730  for (i = 0; i < 4; i++) {
1731  hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
1732  s->linesize) * block_s,
1733  ref_picture[0], 0, 0,
1734  (2 * mb_x + (i & 1)) * block_s,
1735  (2 * mb_y + (i >> 1)) * block_s,
1736  s->width, s->height, s->linesize,
1737  s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1738  block_s, block_s, pix_op,
1739  s->mv[dir][i][0], s->mv[dir][i][1]);
1740 
1741  mx += s->mv[dir][i][0];
1742  my += s->mv[dir][i][1];
1743  }
1744 
1745  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
1746  chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
1747  pix_op, mx, my);
1748  break;
1749  case MV_TYPE_FIELD:
1750  if (s->picture_structure == PICT_FRAME) {
1751  /* top field */
1752  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1753  1, 0, s->field_select[dir][0],
1754  ref_picture, pix_op,
1755  s->mv[dir][0][0], s->mv[dir][0][1],
1756  block_s, mb_y);
1757  /* bottom field */
1758  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1759  1, 1, s->field_select[dir][1],
1760  ref_picture, pix_op,
1761  s->mv[dir][1][0], s->mv[dir][1][1],
1762  block_s, mb_y);
1763  } else {
1764  if (s->picture_structure != s->field_select[dir][0] + 1 &&
1765  s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
1766  ref_picture = s->current_picture_ptr->f->data;
1767 
1768  }
1769  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1770  0, 0, s->field_select[dir][0],
1771  ref_picture, pix_op,
1772  s->mv[dir][0][0],
1773  s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
1774  }
1775  break;
1776  case MV_TYPE_16X8:
1777  for (i = 0; i < 2; i++) {
1778  uint8_t **ref2picture;
1779 
1780  if (s->picture_structure == s->field_select[dir][i] + 1 ||
1781  s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
1782  ref2picture = ref_picture;
1783  } else {
1784  ref2picture = s->current_picture_ptr->f->data;
1785  }
1786 
1787  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1788  0, 0, s->field_select[dir][i],
1789  ref2picture, pix_op,
1790  s->mv[dir][i][0], s->mv[dir][i][1] +
1791  2 * block_s * i, block_s, mb_y >> 1);
1792 
1793  dest_y += 2 * block_s * s->linesize;
1794  dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1795  dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1796  }
1797  break;
1798  case MV_TYPE_DMV:
1799  if (s->picture_structure == PICT_FRAME) {
1800  for (i = 0; i < 2; i++) {
1801  int j;
1802  for (j = 0; j < 2; j++) {
1803  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1804  1, j, j ^ i,
1805  ref_picture, pix_op,
1806  s->mv[dir][2 * i + j][0],
1807  s->mv[dir][2 * i + j][1],
1808  block_s, mb_y);
1809  }
1810  pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1811  }
1812  } else {
1813  for (i = 0; i < 2; i++) {
1814  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1815  0, 0, s->picture_structure != i + 1,
1816  ref_picture, pix_op,
1817  s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
1818  2 * block_s, mb_y >> 1);
1819 
1820  // after put we make avg of the same block
1821  pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1822 
1823  // opposite parity is always in the same
1824  // frame if this is second field
1825  if (!s->first_field) {
1826  ref_picture = s->current_picture_ptr->f->data;
1827  }
1828  }
1829  }
1830  break;
1831  default:
1832  av_assert2(0);
1833  }
1834 }
1835 
1836 /**
1837  * find the lowest MB row referenced in the MVs
1838  */
1840 {
1841  int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1842  int my, off, i, mvs;
1843 
1844  if (s->picture_structure != PICT_FRAME || s->mcsel)
1845  goto unhandled;
1846 
1847  switch (s->mv_type) {
1848  case MV_TYPE_16X16:
1849  mvs = 1;
1850  break;
1851  case MV_TYPE_16X8:
1852  mvs = 2;
1853  break;
1854  case MV_TYPE_8X8:
1855  mvs = 4;
1856  break;
1857  default:
1858  goto unhandled;
1859  }
1860 
1861  for (i = 0; i < mvs; i++) {
1862  my = s->mv[dir][i][1];
1863  my_max = FFMAX(my_max, my);
1864  my_min = FFMIN(my_min, my);
1865  }
1866 
1867  off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
1868 
1869  return av_clip(s->mb_y + off, 0, s->mb_height - 1);
1870 unhandled:
1871  return s->mb_height-1;
1872 }
1873 
1874 /* put block[] to dest[] */
1875 static inline void put_dct(MpegEncContext *s,
1876  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1877 {
1878  s->dct_unquantize_intra(s, block, i, qscale);
1879  s->idsp.idct_put(dest, line_size, block);
1880 }
1881 
1882 /* add block[] to dest[] */
1883 static inline void add_dct(MpegEncContext *s,
1884  int16_t *block, int i, uint8_t *dest, int line_size)
1885 {
1886  if (s->block_last_index[i] >= 0) {
1887  s->idsp.idct_add(dest, line_size, block);
1888  }
1889 }
1890 
1891 static inline void add_dequant_dct(MpegEncContext *s,
1892  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1893 {
1894  if (s->block_last_index[i] >= 0) {
1895  s->dct_unquantize_inter(s, block, i, qscale);
1896 
1897  s->idsp.idct_add(dest, line_size, block);
1898  }
1899 }
1900 
1901 /**
1902  * Clean dc, ac, coded_block for the current non-intra MB.
1903  */
1905 {
1906  int wrap = s->b8_stride;
1907  int xy = s->block_index[0];
1908 
1909  s->dc_val[0][xy ] =
1910  s->dc_val[0][xy + 1 ] =
1911  s->dc_val[0][xy + wrap] =
1912  s->dc_val[0][xy + 1 + wrap] = 1024;
1913  /* ac pred */
1914  memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1915  memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1916  if (s->msmpeg4_version>=3) {
1917  s->coded_block[xy ] =
1918  s->coded_block[xy + 1 ] =
1919  s->coded_block[xy + wrap] =
1920  s->coded_block[xy + 1 + wrap] = 0;
1921  }
1922  /* chroma */
1923  wrap = s->mb_stride;
1924  xy = s->mb_x + s->mb_y * wrap;
1925  s->dc_val[1][xy] =
1926  s->dc_val[2][xy] = 1024;
1927  /* ac pred */
1928  memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1929  memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1930 
1931  s->mbintra_table[xy]= 0;
1932 }
1933 
1934 /* generic function called after a macroblock has been parsed by the
1935  decoder or after it has been encoded by the encoder.
1936 
1937  Important variables used:
1938  s->mb_intra : true if intra macroblock
1939  s->mv_dir : motion vector direction
1940  s->mv_type : motion vector type
1941  s->mv : motion vector
1942  s->interlaced_dct : true if interlaced dct used (mpeg2)
1943  */
1944 static av_always_inline
1946  int lowres_flag, int is_mpeg12)
1947 {
1948  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1949 
1950  if (CONFIG_XVMC &&
1951  s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
1952  s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
1953  return;
1954  }
1955 
1956  if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1957  /* print DCT coefficients */
1958  int i,j;
1959  av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1960  for(i=0; i<6; i++){
1961  for(j=0; j<64; j++){
1962  av_log(s->avctx, AV_LOG_DEBUG, "%5d",
1963  block[i][s->idsp.idct_permutation[j]]);
1964  }
1965  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1966  }
1967  }
1968 
1969  s->current_picture.qscale_table[mb_xy] = s->qscale;
1970 
1971  /* update DC predictors for P macroblocks */
1972  if (!s->mb_intra) {
1973  if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1974  if(s->mbintra_table[mb_xy])
1976  } else {
1977  s->last_dc[0] =
1978  s->last_dc[1] =
1979  s->last_dc[2] = 128 << s->intra_dc_precision;
1980  }
1981  }
1982  else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1983  s->mbintra_table[mb_xy]=1;
1984 
1985  if ((s->avctx->flags & AV_CODEC_FLAG_PSNR) || s->frame_skip_threshold || s->frame_skip_factor ||
1986  !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
1987  s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
1988  uint8_t *dest_y, *dest_cb, *dest_cr;
1989  int dct_linesize, dct_offset;
1990  op_pixels_func (*op_pix)[4];
1991  qpel_mc_func (*op_qpix)[16];
1992  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
1993  const int uvlinesize = s->current_picture.f->linesize[1];
1994  const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1995  const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1996 
1997  /* avoid copy if macroblock skipped in last frame too */
1998  /* skip only during decoding as we might trash the buffers during encoding a bit */
1999  if(!s->encoding){
2000  uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2001 
2002  if (s->mb_skipped) {
2003  s->mb_skipped= 0;
2004  av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2005  *mbskip_ptr = 1;
2006  } else if(!s->current_picture.reference) {
2007  *mbskip_ptr = 1;
2008  } else{
2009  *mbskip_ptr = 0; /* not skipped */
2010  }
2011  }
2012 
2013  dct_linesize = linesize << s->interlaced_dct;
2014  dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2015 
2016  if(readable){
2017  dest_y= s->dest[0];
2018  dest_cb= s->dest[1];
2019  dest_cr= s->dest[2];
2020  }else{
2021  dest_y = s->sc.b_scratchpad;
2022  dest_cb= s->sc.b_scratchpad+16*linesize;
2023  dest_cr= s->sc.b_scratchpad+32*linesize;
2024  }
2025 
2026  if (!s->mb_intra) {
2027  /* motion handling */
2028  /* decoding or more than one mb_type (MC was already done otherwise) */
2029  if(!s->encoding){
2030 
2031  if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2032  if (s->mv_dir & MV_DIR_FORWARD) {
2033  ff_thread_await_progress(&s->last_picture_ptr->tf,
2035  0);
2036  }
2037  if (s->mv_dir & MV_DIR_BACKWARD) {
2038  ff_thread_await_progress(&s->next_picture_ptr->tf,
2040  0);
2041  }
2042  }
2043 
2044  if(lowres_flag){
2045  h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2046 
2047  if (s->mv_dir & MV_DIR_FORWARD) {
2048  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
2049  op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2050  }
2051  if (s->mv_dir & MV_DIR_BACKWARD) {
2052  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
2053  }
2054  }else{
2055  op_qpix = s->me.qpel_put;
2056  if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2057  op_pix = s->hdsp.put_pixels_tab;
2058  }else{
2059  op_pix = s->hdsp.put_no_rnd_pixels_tab;
2060  }
2061  if (s->mv_dir & MV_DIR_FORWARD) {
2062  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2063  op_pix = s->hdsp.avg_pixels_tab;
2064  op_qpix= s->me.qpel_avg;
2065  }
2066  if (s->mv_dir & MV_DIR_BACKWARD) {
2067  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2068  }
2069  }
2070  }
2071 
2072  /* skip dequant / idct if we are really late ;) */
2073  if(s->avctx->skip_idct){
2074  if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2075  ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2076  || s->avctx->skip_idct >= AVDISCARD_ALL)
2077  goto skip_idct;
2078  }
2079 
2080  /* add dct residue */
2081  if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2082  || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2083  add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2084  add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2085  add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2086  add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2087 
2088  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2089  if (s->chroma_y_shift){
2090  add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2091  add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2092  }else{
2093  dct_linesize >>= 1;
2094  dct_offset >>=1;
2095  add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2096  add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2097  add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2098  add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2099  }
2100  }
2101  } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2102  add_dct(s, block[0], 0, dest_y , dct_linesize);
2103  add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2104  add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2105  add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2106 
2107  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2108  if(s->chroma_y_shift){//Chroma420
2109  add_dct(s, block[4], 4, dest_cb, uvlinesize);
2110  add_dct(s, block[5], 5, dest_cr, uvlinesize);
2111  }else{
2112  //chroma422
2113  dct_linesize = uvlinesize << s->interlaced_dct;
2114  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2115 
2116  add_dct(s, block[4], 4, dest_cb, dct_linesize);
2117  add_dct(s, block[5], 5, dest_cr, dct_linesize);
2118  add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2119  add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2120  if(!s->chroma_x_shift){//Chroma444
2121  add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2122  add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2123  add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2124  add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2125  }
2126  }
2127  }//fi gray
2128  }
2130  ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2131  }
2132  } else {
2133  /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
2134  TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
2135  if (s->avctx->bits_per_raw_sample > 8){
2136  const int act_block_size = block_size * 2;
2137 
2138  if(s->dpcm_direction == 0) {
2139  s->idsp.idct_put(dest_y, dct_linesize, (int16_t*)(*s->block32)[0]);
2140  s->idsp.idct_put(dest_y + act_block_size, dct_linesize, (int16_t*)(*s->block32)[1]);
2141  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, (int16_t*)(*s->block32)[2]);
2142  s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)(*s->block32)[3]);
2143 
2144  dct_linesize = uvlinesize << s->interlaced_dct;
2145  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2146 
2147  s->idsp.idct_put(dest_cb, dct_linesize, (int16_t*)(*s->block32)[4]);
2148  s->idsp.idct_put(dest_cr, dct_linesize, (int16_t*)(*s->block32)[5]);
2149  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)(*s->block32)[6]);
2150  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)(*s->block32)[7]);
2151  if(!s->chroma_x_shift){//Chroma444
2152  s->idsp.idct_put(dest_cb + act_block_size, dct_linesize, (int16_t*)(*s->block32)[8]);
2153  s->idsp.idct_put(dest_cr + act_block_size, dct_linesize, (int16_t*)(*s->block32)[9]);
2154  s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[10]);
2155  s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[11]);
2156  }
2157  } else if(s->dpcm_direction == 1) {
2158  int i, w, h;
2159  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2160  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2161  for(i = 0; i < 3; i++) {
2162  int idx = 0;
2163  int vsub = i ? s->chroma_y_shift : 0;
2164  int hsub = i ? s->chroma_x_shift : 0;
2165  for(h = 0; h < (16 >> vsub); h++){
2166  for(w = 0; w < (16 >> hsub); w++)
2167  dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2168  dest_pcm[i] += linesize[i] / 2;
2169  }
2170  }
2171  } else if(s->dpcm_direction == -1) {
2172  int i, w, h;
2173  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2174  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2175  for(i = 0; i < 3; i++) {
2176  int idx = 0;
2177  int vsub = i ? s->chroma_y_shift : 0;
2178  int hsub = i ? s->chroma_x_shift : 0;
2179  dest_pcm[i] += (linesize[i] / 2) * ((16 >> vsub) - 1);
2180  for(h = (16 >> vsub)-1; h >= 1; h--){
2181  for(w = (16 >> hsub)-1; w >= 1; w--)
2182  dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2183  dest_pcm[i] -= linesize[i] / 2;
2184  }
2185  }
2186  }
2187  }
2188  /* dct only in intra block */
2189  else if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2190  put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2191  put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2192  put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2193  put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2194 
2195  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2196  if(s->chroma_y_shift){
2197  put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2198  put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2199  }else{
2200  dct_offset >>=1;
2201  dct_linesize >>=1;
2202  put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2203  put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2204  put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2205  put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2206  }
2207  }
2208  }else{
2209  s->idsp.idct_put(dest_y, dct_linesize, block[0]);
2210  s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2211  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
2212  s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2213 
2214  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2215  if(s->chroma_y_shift){
2216  s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2217  s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2218  }else{
2219 
2220  dct_linesize = uvlinesize << s->interlaced_dct;
2221  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2222 
2223  s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
2224  s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
2225  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2226  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2227  if(!s->chroma_x_shift){//Chroma444
2228  s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2229  s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2230  s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2231  s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2232  }
2233  }
2234  }//gray
2235  }
2236  }
2237 skip_idct:
2238  if(!readable){
2239  s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2240  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2241  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2242  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2243  }
2244  }
2245  }
2246 }
2247 
2249 {
2250 #if !CONFIG_SMALL
2251  if(s->out_format == FMT_MPEG1) {
2252  if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1);
2253  else mpv_reconstruct_mb_internal(s, block, 0, 1);
2254  } else
2255 #endif
2256  if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0);
2257  else mpv_reconstruct_mb_internal(s, block, 0, 0);
2258 }
2259 
2261 {
2262  ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
2263  s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
2264  s->first_field, s->low_delay);
2265 }
2266 
2267 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2268  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2269  const int uvlinesize = s->current_picture.f->linesize[1];
2270  const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
2271  const int height_of_mb = 4 - s->avctx->lowres;
2272 
2273  s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2274  s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2275  s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2276  s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2277  s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2278  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;
2279  //block_index is not used by mpeg2, so it is not affected by chroma_format
2280 
2281  s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << width_of_mb);
2282  s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2283  s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2284 
2285  if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2286  {
2287  if(s->picture_structure==PICT_FRAME){
2288  s->dest[0] += s->mb_y * linesize << height_of_mb;
2289  s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2290  s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2291  }else{
2292  s->dest[0] += (s->mb_y>>1) * linesize << height_of_mb;
2293  s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2294  s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2295  av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2296  }
2297  }
2298 }
2299 
2301  int i;
2302  MpegEncContext *s = avctx->priv_data;
2303 
2304  if (!s || !s->picture)
2305  return;
2306 
2307  for (i = 0; i < MAX_PICTURE_COUNT; i++)
2308  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2309  s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2310 
2311  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
2312  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
2313  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
2314 
2315  s->mb_x= s->mb_y= 0;
2316  s->closed_gop= 0;
2317 
2318  s->parse_context.state= -1;
2319  s->parse_context.frame_start_found= 0;
2320  s->parse_context.overread= 0;
2321  s->parse_context.overread_index= 0;
2322  s->parse_context.index= 0;
2323  s->parse_context.last_index= 0;
2324  s->bitstream_buffer_size=0;
2325  s->pp_time=0;
2326 }
2327 
2328 /**
2329  * set qscale and update qscale dependent variables.
2330  */
2331 void ff_set_qscale(MpegEncContext * s, int qscale)
2332 {
2333  if (qscale < 1)
2334  qscale = 1;
2335  else if (qscale > 31)
2336  qscale = 31;
2337 
2338  s->qscale = qscale;
2339  s->chroma_qscale= s->chroma_qscale_table[qscale];
2340 
2341  s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2342  s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2343 }
2344 
2346 {
2347  if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2348  ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2349 }
#define wrap(func)
Definition: neontest.h:65
Macro definitions for various function/variable attributes.
#define av_always_inline
Definition: attributes.h:45
#define av_cold
Definition: attributes.h:88
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1784
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:1027
#define FF_DEBUG_DCT_COEFF
Definition: avcodec.h:1629
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1785
#define FF_BUG_IEDGE
Definition: avcodec.h:1587
#define FF_DEBUG_NOMC
Definition: avcodec.h:1638
#define AV_RL32
Definition: intreadwrite.h:146
#define s(width, name)
Definition: cbs_vp9.c:257
#define f(width, name)
Definition: cbs_vp9.c:255
#define fail()
Definition: checkasm.h:133
#define FFSWAP(type, a, b)
Definition: common.h:108
#define FFMIN(a, b)
Definition: common.h:105
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
#define av_clip
Definition: common.h:122
#define FFMAX(a, b)
Definition: common.h:103
#define CONFIG_WMV2_ENCODER
Definition: config.h:1370
#define CONFIG_XVMC
Definition: config.h:554
#define HAVE_INTRINSICS_NEON
Definition: config.h:241
#define HAVE_THREADS
Definition: config.h:275
#define ARCH_PPC
Definition: config.h:30
#define ARCH_X86
Definition: config.h:39
#define ARCH_ARM
Definition: config.h:20
#define ARCH_MIPS
Definition: config.h:27
#define CONFIG_WMV2_DECODER
Definition: config.h:1005
#define ARCH_ALPHA
Definition: config.h:19
#define CONFIG_GRAY
Definition: config.h:556
#define NULL
Definition: coverity.c:32
static AVFrame * frame
int
static int lowres
Definition: ffplay.c:336
#define MAX_THREADS
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:342
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:312
#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
Decoding only.
Definition: avcodec.h:412
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:70
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:67
@ AV_CODEC_ID_H263
Definition: codec_id.h:53
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:50
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
Definition: avcodec.h:215
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:235
@ AVDISCARD_NONREF
discard all non reference
Definition: avcodec.h:232
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:502
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:285
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
Definition: h264chroma.h:25
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
misc image utilities
int i
Definition: input.c:407
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:55
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:895
#define FF_QSCALE_TYPE_MPEG1
Definition: internal.h:97
int ff_thread_can_start_frame(AVCodecContext *avctx)
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
common internal API header
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:102
#define emms_c()
Definition: internal.h:54
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:103
uint8_t w
Definition: llviddspenc.c:39
int stride
Definition: mace.c:144
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
MJPEG encoder.
#define ME_MAP_SIZE
Definition: motion_est.h:38
static int ff_h263_round_chroma(int x)
Definition: motion_est.h:101
int ff_mpeg_er_init(MpegEncContext *s)
Definition: mpeg_er.c:100
int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, ScratchpadContext *sc, int shared, int encoding, int chroma_x_shift, int chroma_y_shift, int out_format, int mb_stride, int mb_width, int mb_height, int b8_stride, ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
Allocate a Picture.
Definition: mpegpicture.c:232
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
Definition: mpegpicture.c:295
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:440
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:355
void ff_free_picture_tables(Picture *pic)
Definition: mpegpicture.c:454
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:58
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:32
void ff_draw_horiz_band(AVCodecContext *avctx, AVFrame *cur, AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:51
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t(*motion_val[2])[2], int *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegutils.c:103
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
@ FMT_H261
Definition: mpegutils.h:125
@ FMT_MPEG1
Definition: mpegutils.h:124
@ FMT_H263
Definition: mpegutils.h:126
#define PICT_FRAME
Definition: mpegutils.h:39
static int init_context_frame(MpegEncContext *s)
Initialize and allocates MpegEncContext fields dependent on the resolution.
Definition: mpegvideo.c:716
static void add_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size)
Definition: mpegvideo.c:1883
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
Definition: mpegvideo.c:676
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int field_based, int bottom_field, int field_select, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int motion_x, int motion_y, int h, int mb_y)
Definition: mpegvideo.c:1498
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1181
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1111
static void put_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:1875
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1405
static void dct_unquantize_h263_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:244
static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:277
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:913
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:54
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:112
static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:271
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:176
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:499
#define REBASE_PICTURE(pic, new_ctx, old_ctx)
static av_cold int dct_init(MpegEncContext *s)
Definition: mpegvideo.c:284
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2300
static void add_dequant_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:1891
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1420
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:331
static int hpel_motion_lowres(MpegEncContext *s, uint8_t *dest, uint8_t *src, int field_based, int field_select, int src_x, int src_y, int width, int height, ptrdiff_t stride, int h_edge_pos, int v_edge_pos, int w, int h, h264_chroma_mc_func *pix_op, int motion_x, int motion_y)
Definition: mpegvideo.c:1451
static int lowest_referenced_row(MpegEncContext *s, int dir)
find the lowest MB row referenced in the MVs
Definition: mpegvideo.c:1839
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1413
static void chroma_4mv_motion_lowres(MpegEncContext *s, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int mx, int my)
Definition: mpegvideo.c:1637
#define UPDATE_PICTURE(pic)
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2248
static void MPV_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, h264_chroma_mc_func *pix_op)
motion compensation of a single macroblock
Definition: mpegvideo.c:1705
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo.c:699
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:142
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2331
static void free_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:438
static void clear_context(MpegEncContext *s)
Definition: mpegvideo.c:831
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2267
static void free_context_frame(MpegEncContext *s)
Frees and resets MpegEncContext fields depending on the resolution as well as the slice thread contex...
Definition: mpegvideo.c:1004
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:524
static int alloc_picture(MpegEncContext *s, Picture *pic)
Definition: mpegvideo.c:351
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
Definition: mpegvideo.c:469
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:83
static int init_duplicate_contexts(MpegEncContext *s)
Initialize an MpegEncContext's thread contexts.
Definition: mpegvideo.c:414
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:2260
static int init_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:359
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
Definition: mpegvideo.c:1904
#define COPY(a)
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo.c:1055
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:2345
static void gray_frame(AVFrame *frame)
Definition: mpegvideo.c:1161
static void dct_unquantize_h263_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:210
static void free_duplicate_contexts(MpegEncContext *s)
Definition: mpegvideo.c:460
static av_always_inline void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], int lowres_flag, int is_mpeg12)
Definition: mpegvideo.c:1945
mpegvideo header.
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:268
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:263
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:270
void ff_mpv_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, op_pixels_func(*pix_op)[4], qpel_mc_func(*qpix_op)[16])
void ff_mpv_common_init_ppc(MpegEncContext *s)
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:267
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
av_cold void ff_mpv_common_init_axp(MpegEncContext *s)
av_cold void ff_mpv_common_init_arm(MpegEncContext *s)
Definition: mpegvideo_arm.c:43
av_cold void ff_mpv_common_init_mips(MpegEncContext *s)
const uint8_t ff_mpeg2_non_linear_qscale[32]
Definition: mpegvideodata.c:26
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
const uint8_t ff_default_chroma_qscale_table[32]
Definition: mpegvideodata.c:21
const uint8_t ff_alternate_horizontal_scan[64]
Definition: mpegvideodata.c:84
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:95
av_cold void ff_mpegvideodsp_init(MpegVideoDSPContext *c)
Definition: mpegvideodsp.c:110
av_cold void ff_mpv_common_init_neon(MpegEncContext *s)
Definition: mpegvideo.c:126
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2601
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
quarterpel DSP functions
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
#define s1
Definition: regdef.h:38
main external API structure.
Definition: avcodec.h:536
int width
picture width / height.
Definition: avcodec.h:709
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:561
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:1572
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1680
const struct AVCodec * codec
Definition: avcodec.h:545
int coded_height
Definition: avcodec.h:724
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
void * priv_data
Definition: avcodec.h:563
enum AVCodecID id
Definition: codec.h:211
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int coded_picture_number
picture number in bitstream order
Definition: frame.h:432
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int width
Definition: frame.h:376
int height
Definition: frame.h:376
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:391
Data structure for storing block-level encoding information.
Video encoding parameters for a given frame.
MpegEncContext.
Definition: mpegvideo.h:81
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:513
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
ScratchpadContext sc
Definition: mpegvideo.h:202
MotionEstContext me
Definition: mpegvideo.h:282
int16_t(*[12] pblocks)[64]
Definition: mpegvideo.h:511
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
Picture.
Definition: mpegpicture.h:45
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
int reference
Definition: mpegpicture.h:88
int alloc_mb_stride
mb_stride used to allocate tables
Definition: mpegpicture.h:72
struct AVFrame * f
Definition: mpegpicture.h:46
int alloc_mb_width
mb_width used to allocate tables
Definition: mpegpicture.h:70
int8_t * qscale_table
Definition: mpegpicture.h:50
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
int alloc_mb_height
mb_height used to allocate tables
Definition: mpegpicture.h:71
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:36
uint8_t level
Definition: svq3.c:206
#define ff_dlog(a,...)
#define av_freep(p)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
static int16_t block[64]
Definition: dct.c:116
enum AVPictureType last_picture
Definition: movenc.c:69
#define height
#define width
#define me
const char * b
Definition: vf_curves.c:118
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:75
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
AVVideoEncParams * av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type, unsigned int nb_blocks)
Allocates memory for AVEncodeInfoFrame plus an array of.
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
@ AV_VIDEO_ENC_PARAMS_MPEG2
void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
Definition: wmv2.c:83
av_cold void ff_mpv_common_init_x86(MpegEncContext *s)
Definition: mpegvideo.c:454