interlaced motion estimation
[libav.git] / libavcodec / mpeg12.c
CommitLineData
de6d9b64 1/*
983e3246 2 * MPEG1 codec / MPEG2 decoder
ff4ec49e 3 * Copyright (c) 2000,2001 Fabrice Bellard.
de6d9b64 4 *
ff4ec49e
FB
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
de6d9b64 9 *
ff4ec49e 10 * This library is distributed in the hope that it will be useful,
de6d9b64 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
ff4ec49e
FB
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
de6d9b64 14 *
ff4ec49e
FB
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
de6d9b64 18 */
983e3246
MN
19
20/**
21 * @file mpeg12.c
029911d1 22 * MPEG1/2 codec
983e3246
MN
23 */
24
a74127c0 25//#define DEBUG
de6d9b64
FB
26#include "avcodec.h"
27#include "dsputil.h"
28#include "mpegvideo.h"
29
30#include "mpeg12data.h"
31
bb198e19
MN
32//#undef NDEBUG
33//#include <assert.h>
34
d87c0267 35
de6d9b64
FB
36/* Start codes. */
37#define SEQ_END_CODE 0x000001b7
38#define SEQ_START_CODE 0x000001b3
39#define GOP_START_CODE 0x000001b8
40#define PICTURE_START_CODE 0x00000100
41#define SLICE_MIN_START_CODE 0x00000101
42#define SLICE_MAX_START_CODE 0x000001af
43#define EXT_START_CODE 0x000001b5
44#define USER_START_CODE 0x000001b2
45
4f68b084
MN
46#define DC_VLC_BITS 9
47#define MV_VLC_BITS 9
48#define MBINCR_VLC_BITS 9
49#define MB_PAT_VLC_BITS 9
50#define MB_PTYPE_VLC_BITS 6
51#define MB_BTYPE_VLC_BITS 6
52#define TEX_VLC_BITS 9
53
764ef400 54#ifdef CONFIG_ENCODERS
de6d9b64
FB
55static void mpeg1_encode_block(MpegEncContext *s,
56 DCTELEM *block,
57 int component);
63b15e55 58static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added
764ef400 59#endif //CONFIG_ENCODERS
de6d9b64 60static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
a0201736
MN
61static inline int mpeg1_decode_block_inter(MpegEncContext *s,
62 DCTELEM *block,
63 int n);
64static inline int mpeg1_decode_block_intra(MpegEncContext *s,
de6d9b64
FB
65 DCTELEM *block,
66 int n);
3729c912 67static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
de6d9b64
FB
68 DCTELEM *block,
69 int n);
3729c912 70static inline int mpeg2_decode_block_intra(MpegEncContext *s,
de6d9b64
FB
71 DCTELEM *block,
72 int n);
73static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
57489bc5 74static void exchange_uv(MpegEncContext *s);
de6d9b64 75
2e7b4c84
IK
76#ifdef HAVE_XVMC
77extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx);
78extern int XVMC_field_end(MpegEncContext *s);
a579db0c 79extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp);
57489bc5 80extern void XVMC_init_block(MpegEncContext *s);//set s->block
2e7b4c84
IK
81#endif
82
c442d75c 83#ifdef CONFIG_ENCODERS
30952237 84static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL;
0c1a9eda 85static uint8_t fcode_tab[MAX_MV*2+1];
11ce8834 86
c442d75c
MN
87static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2];
88static uint8_t uni_mpeg1_ac_vlc_len [64*64*2];
2a250222
MN
89
90/* simple include everything table for dc, first byte is bits number next 3 are code*/
91static uint32_t mpeg1_lum_dc_uni[512];
92static uint32_t mpeg1_chr_dc_uni[512];
93
94static uint8_t mpeg1_index_run[2][64];
95static int8_t mpeg1_max_level[2][64];
764ef400 96#endif //CONFIG_ENCODERS
c442d75c 97
4f68b084
MN
98static void init_2d_vlc_rl(RLTable *rl)
99{
07787186 100 int i;
4f68b084
MN
101
102 init_vlc(&rl->vlc, TEX_VLC_BITS, rl->n + 2,
103 &rl->table_vlc[0][1], 4, 2,
104 &rl->table_vlc[0][0], 4, 2);
105
106
107 rl->rl_vlc[0]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
108 for(i=0; i<rl->vlc.table_size; i++){
109 int code= rl->vlc.table[i][0];
110 int len = rl->vlc.table[i][1];
111 int level, run;
112
113 if(len==0){ // illegal code
114 run= 65;
115 level= MAX_LEVEL;
116 }else if(len<0){ //more bits needed
117 run= 0;
118 level= code;
119 }else{
120 if(code==rl->n){ //esc
121 run= 65;
122 level= 0;
123 }else if(code==rl->n+1){ //eob
a0201736
MN
124 run= 0;
125 level= 127;
4f68b084
MN
126 }else{
127 run= rl->table_run [code] + 1;
128 level= rl->table_level[code];
129 }
130 }
131 rl->rl_vlc[0][i].len= len;
132 rl->rl_vlc[0][i].level= level;
133 rl->rl_vlc[0][i].run= run;
134 }
135}
136
2a250222 137#ifdef CONFIG_ENCODERS
c442d75c
MN
138static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){
139 int i;
140
141 for(i=0; i<128; i++){
142 int level= i-64;
143 int run;
144 for(run=0; run<64; run++){
145 int len, bits, code;
146
147 int alevel= ABS(level);
148 int sign= (level>>31)&1;
149
150 if (alevel > rl->max_level[0][run])
151 code= 111; /*rl->n*/
152 else
153 code= rl->index_run[0][run] + alevel - 1;
154
155 if (code < 111 /* rl->n */) {
156 /* store the vlc & sign at once */
157 len= mpeg1_vlc[code][1]+1;
158 bits= (mpeg1_vlc[code][0]<<1) + sign;
159 } else {
160 len= mpeg1_vlc[111/*rl->n*/][1]+6;
161 bits= mpeg1_vlc[111/*rl->n*/][0]<<6;
162
163 bits|= run;
164 if (alevel < 128) {
165 bits<<=8; len+=8;
166 bits|= level & 0xff;
167 } else {
168 bits<<=16; len+=16;
169 bits|= level & 0xff;
170 if (level < 0) {
171 bits|= 0x8001 + level + 255;
172 } else {
173 bits|= level & 0xffff;
174 }
175 }
176 }
177
178 uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits;
179 uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len;
180 }
181 }
182}
4f68b084 183
de6d9b64
FB
184static void put_header(MpegEncContext *s, int header)
185{
186 align_put_bits(&s->pb);
80feb2a2
MN
187 put_bits(&s->pb, 16, header>>16);
188 put_bits(&s->pb, 16, header&0xFFFF);
de6d9b64
FB
189}
190
191/* put sequence header if needed */
192static void mpeg1_encode_sequence_header(MpegEncContext *s)
193{
194 unsigned int vbv_buffer_size;
d78647e8 195 unsigned int fps, v;
426b8061 196 int n, i;
0c1a9eda 197 uint64_t time_code;
426b8061 198 float best_aspect_error= 1E10;
5ff85f1d 199 float aspect_ratio= av_q2d(s->avctx->sample_aspect_ratio);
98b0858e 200 int constraint_parameter_flag;
426b8061 201
5ff85f1d 202 if(aspect_ratio==0.0) aspect_ratio= 1.0; //pixel aspect 1:1 (VGA)
de6d9b64 203
1e491e29 204 if (s->current_picture.key_frame) {
de6d9b64
FB
205 /* mpeg1 header repeated every gop */
206 put_header(s, SEQ_START_CODE);
207
208 /* search closest frame rate */
209 {
210 int i, dmin, d;
211 s->frame_rate_index = 0;
212 dmin = 0x7fffffff;
14bea432
MN
213 for(i=1;i<14;i++) {
214 if(s->avctx->strict_std_compliance >= 0 && i>=9) break;
215
216 d = abs(MPEG1_FRAME_RATE_BASE*(int64_t)s->avctx->frame_rate/s->avctx->frame_rate_base - frame_rate_tab[i]);
de6d9b64
FB
217 if (d < dmin) {
218 dmin = d;
219 s->frame_rate_index = i;
220 }
221 }
222 }
223
224 put_bits(&s->pb, 12, s->width);
225 put_bits(&s->pb, 12, s->height);
426b8061
MN
226
227 for(i=1; i<15; i++){
5c9e4723
MN
228 float error= aspect_ratio;
229 if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1)
f259747b 230 error-= 1.0/mpeg1_aspect[i];
5c9e4723
MN
231 else
232 error-= av_q2d(mpeg2_aspect[i])*s->height/s->width;
233
426b8061
MN
234 error= ABS(error);
235
236 if(error < best_aspect_error){
237 best_aspect_error= error;
238 s->aspect_ratio_info= i;
239 }
240 }
241
242 put_bits(&s->pb, 4, s->aspect_ratio_info);
de6d9b64 243 put_bits(&s->pb, 4, s->frame_rate_index);
12dccd4e
MN
244
245 if(s->avctx->rc_max_rate){
246 v = (s->avctx->rc_max_rate + 399) / 400;
247 if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO)
248 v = 0x3ffff;
249 }else{
250 v= 0x3FFFF;
251 }
ecfd40b3
HM
252
253 if(s->avctx->rc_buffer_size)
254 vbv_buffer_size = s->avctx->rc_buffer_size;
255 else
256 /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */
12dccd4e
MN
257 vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
258 vbv_buffer_size= (vbv_buffer_size + 16383) / 16384;
259
260 put_bits(&s->pb, 18, v & 0x3FFFF);
261 put_bits(&s->pb, 1, 1); /* marker */
98b0858e
MN
262 put_bits(&s->pb, 10, vbv_buffer_size & 0x3FF);
263
264 constraint_parameter_flag=
265 s->width <= 768 && s->height <= 576 &&
266 s->mb_width * s->mb_height <= 396 &&
267 s->mb_width * s->mb_height * frame_rate_tab[s->frame_rate_index] <= MPEG1_FRAME_RATE_BASE*396*25 &&
268 frame_rate_tab[s->frame_rate_index] <= MPEG1_FRAME_RATE_BASE*30 &&
269 vbv_buffer_size <= 20 &&
270 v <= 1856000/400 &&
271 s->codec_id == CODEC_ID_MPEG1VIDEO;
272
273 put_bits(&s->pb, 1, constraint_parameter_flag);
d6eb3c50
MN
274
275 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
276 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);
de6d9b64 277
029911d1
MN
278 if(s->codec_id == CODEC_ID_MPEG2VIDEO){
279 put_header(s, EXT_START_CODE);
280 put_bits(&s->pb, 4, 1); //seq ext
281 put_bits(&s->pb, 1, 0); //esc
282 put_bits(&s->pb, 3, 4); //profile
283 put_bits(&s->pb, 4, 8); //level
3ab5b8cc 284 put_bits(&s->pb, 1, s->progressive_sequence);
029911d1
MN
285 put_bits(&s->pb, 2, 1); //chroma format 4:2:0
286 put_bits(&s->pb, 2, 0); //horizontal size ext
287 put_bits(&s->pb, 2, 0); //vertical size ext
288 put_bits(&s->pb, 12, v>>18); //bitrate ext
289 put_bits(&s->pb, 1, 1); //marker
290 put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext
291 put_bits(&s->pb, 1, s->low_delay);
292 put_bits(&s->pb, 2, 0); // frame_rate_ext_n
293 put_bits(&s->pb, 5, 0); // frame_rate_ext_d
294 }
295
de6d9b64
FB
296 put_header(s, GOP_START_CODE);
297 put_bits(&s->pb, 1, 0); /* do drop frame */
298 /* time code : we must convert from the real frame rate to a
299 fake mpeg frame rate in case of low frame rate */
300 fps = frame_rate_tab[s->frame_rate_index];
14bea432 301 time_code = (int64_t)s->fake_picture_number * MPEG1_FRAME_RATE_BASE;
de6d9b64 302 s->gop_picture_number = s->fake_picture_number;
0c1a9eda
ZK
303 put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
304 put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
de6d9b64 305 put_bits(&s->pb, 1, 1);
0c1a9eda 306 put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
14bea432 307 put_bits(&s->pb, 6, (uint32_t)((time_code % fps) / MPEG1_FRAME_RATE_BASE));
69b0ff3a 308 put_bits(&s->pb, 1, 0); /* closed gop */
de6d9b64
FB
309 put_bits(&s->pb, 1, 0); /* broken link */
310 }
311
14bea432 312 if (s->avctx->frame_rate < (24 * s->avctx->frame_rate_base) && s->picture_number > 0) {
de6d9b64
FB
313 /* insert empty P pictures to slow down to the desired
314 frame rate. Each fake pictures takes about 20 bytes */
315 fps = frame_rate_tab[s->frame_rate_index];
14bea432 316 n = av_rescale((int64_t)s->picture_number * s->avctx->frame_rate_base, fps, s->avctx->frame_rate) / MPEG1_FRAME_RATE_BASE - 1;
de6d9b64
FB
317 while (s->fake_picture_number < n) {
318 mpeg1_skip_picture(s, s->fake_picture_number -
319 s->gop_picture_number);
320 s->fake_picture_number++;
321 }
322
323 }
de6d9b64
FB
324}
325
9b8709d1
MN
326static inline void encode_mb_skip_run(MpegEncContext *s, int run){
327 while (run >= 33) {
328 put_bits(&s->pb, 11, 0x008);
329 run -= 33;
330 }
331 put_bits(&s->pb, mbAddrIncrTable[run][1],
332 mbAddrIncrTable[run][0]);
333}
de6d9b64
FB
334
335/* insert a fake P picture */
336static void mpeg1_skip_picture(MpegEncContext *s, int pict_num)
337{
029911d1
MN
338 assert(s->codec_id == CODEC_ID_MPEG1VIDEO); // mpeg2 can do these repeat things
339
de6d9b64
FB
340 /* mpeg1 picture header */
341 put_header(s, PICTURE_START_CODE);
342 /* temporal reference */
343 put_bits(&s->pb, 10, pict_num & 0x3ff);
344
345 put_bits(&s->pb, 3, P_TYPE);
346 put_bits(&s->pb, 16, 0xffff); /* non constant bit rate */
347
348 put_bits(&s->pb, 1, 1); /* integer coordinates */
349 put_bits(&s->pb, 3, 1); /* forward_f_code */
350
351 put_bits(&s->pb, 1, 0); /* extra bit picture */
352
353 /* only one slice */
354 put_header(s, SLICE_MIN_START_CODE);
355 put_bits(&s->pb, 5, 1); /* quantizer scale */
356 put_bits(&s->pb, 1, 0); /* slice extra information */
357
9b8709d1 358 encode_mb_skip_run(s, 0);
de6d9b64
FB
359
360 /* empty macroblock */
361 put_bits(&s->pb, 3, 1); /* motion only */
362
363 /* zero motion x & y */
364 put_bits(&s->pb, 1, 1);
365 put_bits(&s->pb, 1, 1);
366
367 /* output a number of empty slice */
9b8709d1 368 encode_mb_skip_run(s, s->mb_width * s->mb_height - 2);
de6d9b64
FB
369
370 /* empty macroblock */
371 put_bits(&s->pb, 3, 1); /* motion only */
372
373 /* zero motion x & y */
374 put_bits(&s->pb, 1, 1);
375 put_bits(&s->pb, 1, 1);
376}
764ef400 377#endif //CONFIG_ENCODERS
de6d9b64 378
8f8402e4 379static void common_init(MpegEncContext *s)
de6d9b64 380{
8f8402e4
MN
381 s->y_dc_scale_table=
382 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
383}
f004ca1c 384
2a250222
MN
385void ff_mpeg1_clean_buffers(MpegEncContext *s){
386 s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
387 s->last_dc[1] = s->last_dc[0];
388 s->last_dc[2] = s->last_dc[0];
389 memset(s->last_mv, 0, sizeof(s->last_mv));
390}
391
7604246d 392#ifdef CONFIG_ENCODERS
9b8709d1
MN
393
394void ff_mpeg1_encode_slice_header(MpegEncContext *s){
395 put_header(s, SLICE_MIN_START_CODE + s->mb_y);
396 put_bits(&s->pb, 5, s->qscale); /* quantizer scale */
397 put_bits(&s->pb, 1, 0); /* slice extra information */
398}
399
8f8402e4
MN
400void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
401{
de6d9b64
FB
402 mpeg1_encode_sequence_header(s);
403
404 /* mpeg1 picture header */
405 put_header(s, PICTURE_START_CODE);
406 /* temporal reference */
63b15e55
MN
407
408 // RAL: s->picture_number instead of s->fake_picture_number
409 put_bits(&s->pb, 10, (s->picture_number -
de6d9b64 410 s->gop_picture_number) & 0x3ff);
af469427 411 s->fake_picture_number++;
de6d9b64
FB
412
413 put_bits(&s->pb, 3, s->pict_type);
d60a8f85
MN
414
415 s->vbv_delay_ptr= s->pb.buf + get_bit_count(&s->pb)/8;
416 put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */
de6d9b64 417
63b15e55
MN
418 // RAL: Forward f_code also needed for B frames
419 if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
de6d9b64 420 put_bits(&s->pb, 1, 0); /* half pel coordinates */
cb231c48
MN
421 if(s->codec_id == CODEC_ID_MPEG1VIDEO)
422 put_bits(&s->pb, 3, s->f_code); /* forward_f_code */
423 else
424 put_bits(&s->pb, 3, 7); /* forward_f_code */
de6d9b64
FB
425 }
426
63b15e55
MN
427 // RAL: Backward f_code necessary for B frames
428 if (s->pict_type == B_TYPE) {
429 put_bits(&s->pb, 1, 0); /* half pel coordinates */
cb231c48
MN
430 if(s->codec_id == CODEC_ID_MPEG1VIDEO)
431 put_bits(&s->pb, 3, s->b_code); /* backward_f_code */
432 else
433 put_bits(&s->pb, 3, 7); /* backward_f_code */
029911d1 434 }
63b15e55 435
de6d9b64 436 put_bits(&s->pb, 1, 0); /* extra bit picture */
3ab5b8cc
FB
437
438 s->frame_pred_frame_dct = 1;
029911d1
MN
439 if(s->codec_id == CODEC_ID_MPEG2VIDEO){
440 put_header(s, EXT_START_CODE);
441 put_bits(&s->pb, 4, 8); //pic ext
cb231c48
MN
442 if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
443 put_bits(&s->pb, 4, s->f_code);
444 put_bits(&s->pb, 4, s->f_code);
445 }else{
446 put_bits(&s->pb, 8, 255);
447 }
448 if (s->pict_type == B_TYPE) {
449 put_bits(&s->pb, 4, s->b_code);
450 put_bits(&s->pb, 4, s->b_code);
451 }else{
452 put_bits(&s->pb, 8, 255);
453 }
029911d1
MN
454 put_bits(&s->pb, 2, s->intra_dc_precision);
455 put_bits(&s->pb, 2, s->picture_structure= PICT_FRAME);
7a0f9d7e
FB
456 if (s->progressive_sequence) {
457 put_bits(&s->pb, 1, 0); /* no repeat */
458 } else {
459 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first);
460 }
3ab5b8cc
FB
461 /* XXX: optimize the generation of this flag with entropy
462 measures */
463 s->frame_pred_frame_dct = s->progressive_sequence;
464
465 put_bits(&s->pb, 1, s->frame_pred_frame_dct);
029911d1
MN
466 put_bits(&s->pb, 1, s->concealment_motion_vectors);
467 put_bits(&s->pb, 1, s->q_scale_type);
468 put_bits(&s->pb, 1, s->intra_vlc_format);
469 put_bits(&s->pb, 1, s->alternate_scan);
470 put_bits(&s->pb, 1, s->repeat_first_field);
471 put_bits(&s->pb, 1, s->chroma_420_type=1);
3ab5b8cc
FB
472 s->progressive_frame = s->progressive_sequence;
473 put_bits(&s->pb, 1, s->progressive_frame);
029911d1
MN
474 put_bits(&s->pb, 1, 0); //composite_display_flag
475 }
476
9b8709d1
MN
477 s->mb_y=0;
478 ff_mpeg1_encode_slice_header(s);
de6d9b64
FB
479}
480
3ab5b8cc 481static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
bb198e19 482 int has_mv, int field_motion)
3ab5b8cc
FB
483{
484 put_bits(&s->pb, n, bits);
485 if (!s->frame_pred_frame_dct) {
486 if (has_mv)
bb198e19 487 put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */
3ab5b8cc
FB
488 put_bits(&s->pb, 1, s->interlaced_dct);
489 }
490}
491
de6d9b64
FB
492void mpeg1_encode_mb(MpegEncContext *s,
493 DCTELEM block[6][64],
494 int motion_x, int motion_y)
495{
9b8709d1
MN
496 int i, cbp;
497 const int mb_x = s->mb_x;
498 const int mb_y = s->mb_y;
499 const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
de6d9b64
FB
500
501 /* compute cbp */
502 cbp = 0;
503 for(i=0;i<6;i++) {
504 if (s->block_last_index[i] >= 0)
505 cbp |= 1 << (5 - i);
506 }
bb198e19 507
029911d1 508 if (cbp == 0 && !first_mb && (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) &&
bb198e19 509 ((s->pict_type == P_TYPE && s->mv_type == MV_TYPE_16X16 && (motion_x | motion_y) == 0) ||
63b15e55
MN
510 (s->pict_type == B_TYPE && s->mv_dir == s->last_mv_dir && (((s->mv_dir & MV_DIR_FORWARD) ? ((s->mv[0][0][0] - s->last_mv[0][0][0])|(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
511 ((s->mv_dir & MV_DIR_BACKWARD) ? ((s->mv[1][0][0] - s->last_mv[1][0][0])|(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
9b8709d1 512 s->mb_skip_run++;
d87c0267 513 s->qscale -= s->dquant;
49733979
MN
514 s->skip_count++;
515 s->misc_bits++;
516 s->last_bits++;
bb198e19
MN
517 if(s->pict_type == P_TYPE){
518 s->last_mv[0][1][0]= s->last_mv[0][0][0]=
519 s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0;
520 }
de6d9b64 521 } else {
9b8709d1
MN
522 if(first_mb){
523 assert(s->mb_skip_run == 0);
524 encode_mb_skip_run(s, s->mb_x);
525 }else{
526 encode_mb_skip_run(s, s->mb_skip_run);
de6d9b64 527 }
de6d9b64
FB
528
529 if (s->pict_type == I_TYPE) {
d87c0267 530 if(s->dquant && cbp){
bb198e19 531 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */
d87c0267
MN
532 put_bits(&s->pb, 5, s->qscale);
533 }else{
bb198e19 534 put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */
d87c0267
MN
535 s->qscale -= s->dquant;
536 }
49733979
MN
537 s->misc_bits+= get_bits_diff(s);
538 s->i_count++;
63b15e55
MN
539 } else if (s->mb_intra) {
540 if(s->dquant && cbp){
bb198e19 541 put_mb_modes(s, 6, 0x01, 0, 0);
63b15e55
MN
542 put_bits(&s->pb, 5, s->qscale);
543 }else{
bb198e19 544 put_mb_modes(s, 5, 0x03, 0, 0);
63b15e55
MN
545 s->qscale -= s->dquant;
546 }
547 s->misc_bits+= get_bits_diff(s);
548 s->i_count++;
bb198e19 549 memset(s->last_mv, 0, sizeof(s->last_mv));
63b15e55 550 } else if (s->pict_type == P_TYPE) {
bb198e19 551 if(s->mv_type == MV_TYPE_16X16){
de6d9b64 552 if (cbp != 0) {
bb198e19 553 if ((motion_x|motion_y) == 0) {
d87c0267 554 if(s->dquant){
bb198e19 555 put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */
d87c0267
MN
556 put_bits(&s->pb, 5, s->qscale);
557 }else{
bb198e19 558 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */
d87c0267 559 }
49733979 560 s->misc_bits+= get_bits_diff(s);
de6d9b64 561 } else {
d87c0267 562 if(s->dquant){
bb198e19 563 put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */
d87c0267
MN
564 put_bits(&s->pb, 5, s->qscale);
565 }else{
bb198e19 566 put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */
d87c0267 567 }
49733979 568 s->misc_bits+= get_bits_diff(s);
63b15e55
MN
569 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added
570 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added
49733979 571 s->mv_bits+= get_bits_diff(s);
de6d9b64
FB
572 }
573 } else {
574 put_bits(&s->pb, 3, 1); /* motion only */
3ab5b8cc
FB
575 if (!s->frame_pred_frame_dct)
576 put_bits(&s->pb, 2, 2); /* motion_type: frame */
bb198e19 577 s->misc_bits+= get_bits_diff(s);
63b15e55
MN
578 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added
579 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added
d87c0267 580 s->qscale -= s->dquant;
49733979 581 s->mv_bits+= get_bits_diff(s);
de6d9b64 582 }
bb198e19
MN
583 s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x;
584 s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y;
585 }else{
586 assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
587
588 if (cbp) {
589 if(s->dquant){
590 put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */
591 put_bits(&s->pb, 5, s->qscale);
592 }else{
593 put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */
63b15e55 594 }
bb198e19
MN
595 } else {
596 put_bits(&s->pb, 3, 1); /* motion only */
597 put_bits(&s->pb, 2, 1); /* motion_type: field */
63b15e55 598 s->qscale -= s->dquant;
bb198e19
MN
599 }
600 s->misc_bits+= get_bits_diff(s);
601 for(i=0; i<2; i++){
602 put_bits(&s->pb, 1, s->field_select[0][i]);
603 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code);
604 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
605 s->last_mv[0][i][0]= s->mv[0][i][0];
606 s->last_mv[0][i][1]= 2*s->mv[0][i][1];
607 }
608 s->mv_bits+= get_bits_diff(s);
609 }
610 if(cbp)
611 put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
612 s->f_count++;
613 } else{
614 static const int mb_type_len[4]={0,3,4,2}; //bak,for,bi
615
616 if(s->mv_type == MV_TYPE_16X16){
617 if (cbp){ // With coded bloc pattern
618 if (s->dquant) {
619 if(s->mv_dir == MV_DIR_FORWARD)
620 put_mb_modes(s, 6, 3, 1, 0);
621 else
622 put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 0);
623 put_bits(&s->pb, 5, s->qscale);
624 } else {
625 put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 0);
626 }
627 }else{ // No coded bloc pattern
628 put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
629 if (!s->frame_pred_frame_dct)
630 put_bits(&s->pb, 2, 2); /* motion_type: frame */
631 s->qscale -= s->dquant;
632 }
633 s->misc_bits += get_bits_diff(s);
634 if (s->mv_dir&MV_DIR_FORWARD){
635 mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
636 mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
637 s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0];
638 s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1];
639 s->f_count++;
640 }
641 if (s->mv_dir&MV_DIR_BACKWARD){
642 mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
643 mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
644 s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0];
645 s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1];
646 s->b_count++;
647 }
648 }else{
649 assert(s->mv_type == MV_TYPE_FIELD);
650 assert(!s->frame_pred_frame_dct);
651 if (cbp){ // With coded bloc pattern
652 if (s->dquant) {
653 if(s->mv_dir == MV_DIR_FORWARD)
654 put_mb_modes(s, 6, 3, 1, 1);
655 else
656 put_mb_modes(s, mb_type_len[s->mv_dir]+3, 2, 1, 1);
657 put_bits(&s->pb, 5, s->qscale);
658 } else {
659 put_mb_modes(s, mb_type_len[s->mv_dir], 3, 1, 1);
63b15e55 660 }
bb198e19
MN
661 }else{ // No coded bloc pattern
662 put_bits(&s->pb, mb_type_len[s->mv_dir], 2);
663 put_bits(&s->pb, 2, 1); /* motion_type: field */
664 s->qscale -= s->dquant;
665 }
666 s->misc_bits += get_bits_diff(s);
667 if (s->mv_dir&MV_DIR_FORWARD){
668 for(i=0; i<2; i++){
669 put_bits(&s->pb, 1, s->field_select[0][i]);
670 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code);
671 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code);
672 s->last_mv[0][i][0]= s->mv[0][i][0];
673 s->last_mv[0][i][1]= 2*s->mv[0][i][1];
674 }
675 s->f_count++;
676 }
677 if (s->mv_dir&MV_DIR_BACKWARD){
678 for(i=0; i<2; i++){
679 put_bits(&s->pb, 1, s->field_select[1][i]);
680 mpeg1_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code);
681 mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code);
682 s->last_mv[1][i][0]= s->mv[1][i][0];
683 s->last_mv[1][i][1]= 2*s->mv[1][i][1];
684 }
685 s->b_count++;
686 }
de6d9b64 687 }
bb198e19
MN
688 s->mv_bits += get_bits_diff(s);
689 if(cbp)
690 put_bits(&s->pb, mbPatTable[cbp - 1][1], mbPatTable[cbp - 1][0]);
691 }
de6d9b64
FB
692 for(i=0;i<6;i++) {
693 if (cbp & (1 << (5 - i))) {
694 mpeg1_encode_block(s, block[i], i);
695 }
696 }
9b8709d1 697 s->mb_skip_run = 0;
49733979
MN
698 if(s->mb_intra)
699 s->i_tex_bits+= get_bits_diff(s);
700 else
701 s->p_tex_bits+= get_bits_diff(s);
de6d9b64 702 }
de6d9b64
FB
703}
704
63b15e55
MN
705// RAL: Parameter added: f_or_b_code
706static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
de6d9b64
FB
707{
708 int code, bit_size, l, m, bits, range, sign;
709
710 if (val == 0) {
711 /* zero vector */
712 code = 0;
713 put_bits(&s->pb,
714 mbMotionVectorTable[0][1],
715 mbMotionVectorTable[0][0]);
716 } else {
63b15e55 717 bit_size = f_or_b_code - 1;
de6d9b64
FB
718 range = 1 << bit_size;
719 /* modulo encoding */
720 l = 16 * range;
721 m = 2 * l;
722 if (val < -l) {
723 val += m;
724 } else if (val >= l) {
725 val -= m;
726 }
727
728 if (val >= 0) {
729 val--;
730 code = (val >> bit_size) + 1;
731 bits = val & (range - 1);
732 sign = 0;
733 } else {
734 val = -val;
735 val--;
736 code = (val >> bit_size) + 1;
737 bits = val & (range - 1);
738 sign = 1;
739 }
63b15e55
MN
740
741 assert(code > 0 && code <= 16);
742
de6d9b64
FB
743 put_bits(&s->pb,
744 mbMotionVectorTable[code][1],
745 mbMotionVectorTable[code][0]);
63b15e55 746
de6d9b64
FB
747 put_bits(&s->pb, 1, sign);
748 if (bit_size > 0) {
749 put_bits(&s->pb, bit_size, bits);
750 }
751 }
752}
753
8f8402e4 754void ff_mpeg1_encode_init(MpegEncContext *s)
11ce8834
MN
755{
756 static int done=0;
8f8402e4
MN
757
758 common_init(s);
759
11ce8834
MN
760 if(!done){
761 int f_code;
762 int mv;
8f8402e4 763 int i;
11ce8834
MN
764
765 done=1;
8f8402e4 766 init_rl(&rl_mpeg1);
c442d75c 767
8f8402e4
MN
768 for(i=0; i<64; i++)
769 {
770 mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i];
771 mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i];
772 }
c442d75c
MN
773
774 init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len);
8f8402e4
MN
775
776 /* build unified dc encoding tables */
777 for(i=-255; i<256; i++)
778 {
779 int adiff, index;
780 int bits, code;
781 int diff=i;
782
783 adiff = ABS(diff);
784 if(diff<0) diff--;
785 index = vlc_dc_table[adiff];
786
787 bits= vlc_dc_lum_bits[index] + index;
788 code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1));
789 mpeg1_lum_dc_uni[i+255]= bits + (code<<8);
790
791 bits= vlc_dc_chroma_bits[index] + index;
792 code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1));
793 mpeg1_chr_dc_uni[i+255]= bits + (code<<8);
794 }
795
30952237
MN
796 mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
797
11ce8834
MN
798 for(f_code=1; f_code<=MAX_FCODE; f_code++){
799 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
800 int len;
801
802 if(mv==0) len= mbMotionVectorTable[0][1];
803 else{
804 int val, bit_size, range, code;
805
806 bit_size = s->f_code - 1;
807 range = 1 << bit_size;
808
809 val=mv;
810 if (val < 0)
811 val = -val;
812 val--;
813 code = (val >> bit_size) + 1;
814 if(code<17){
815 len= mbMotionVectorTable[code][1] + 1 + bit_size;
816 }else{
817 len= mbMotionVectorTable[16][1] + 2 + bit_size;
818 }
819 }
820
821 mv_penalty[f_code][mv+MAX_MV]= len;
822 }
823 }
824
825
826 for(f_code=MAX_FCODE; f_code>0; f_code--){
827 for(mv=-(8<<f_code); mv<(8<<f_code); mv++){
828 fcode_tab[mv+MAX_MV]= f_code;
829 }
830 }
831 }
1457ab52 832 s->me.mv_penalty= mv_penalty;
11ce8834 833 s->fcode_tab= fcode_tab;
029911d1
MN
834 if(s->codec_id == CODEC_ID_MPEG1VIDEO){
835 s->min_qcoeff=-255;
836 s->max_qcoeff= 255;
837 }else{
838 s->min_qcoeff=-2047;
839 s->max_qcoeff= 2047;
840 }
c442d75c 841 s->intra_ac_vlc_length=
e5021fff
MN
842 s->inter_ac_vlc_length=
843 s->intra_ac_vlc_last_length=
844 s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len;
11ce8834 845}
8f8402e4 846
de6d9b64
FB
847static inline void encode_dc(MpegEncContext *s, int diff, int component)
848{
de6d9b64 849 if (component == 0) {
f004ca1c
MN
850 put_bits(
851 &s->pb,
852 mpeg1_lum_dc_uni[diff+255]&0xFF,
853 mpeg1_lum_dc_uni[diff+255]>>8);
de6d9b64 854 } else {
f004ca1c
MN
855 put_bits(
856 &s->pb,
857 mpeg1_chr_dc_uni[diff+255]&0xFF,
858 mpeg1_chr_dc_uni[diff+255]>>8);
de6d9b64
FB
859 }
860}
861
862static void mpeg1_encode_block(MpegEncContext *s,
863 DCTELEM *block,
864 int n)
865{
866 int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
867 int code, component;
80feb2a2 868// RLTable *rl = &rl_mpeg1;
de6d9b64
FB
869
870 last_index = s->block_last_index[n];
871
872 /* DC coef */
873 if (s->mb_intra) {
874 component = (n <= 3 ? 0 : n - 4 + 1);
875 dc = block[0]; /* overflow is impossible */
876 diff = dc - s->last_dc[component];
877 encode_dc(s, diff, component);
878 s->last_dc[component] = dc;
879 i = 1;
029911d1
MN
880/*
881 if (s->intra_vlc_format)
882 rl = &rl_mpeg2;
883 else
884 rl = &rl_mpeg1;
885*/
de6d9b64
FB
886 } else {
887 /* encode the first coefficient : needs to be done here because
888 it is handled slightly differently */
889 level = block[0];
890 if (abs(level) == 1) {
0c1a9eda 891 code = ((uint32_t)level >> 31); /* the sign bit */
de6d9b64
FB
892 put_bits(&s->pb, 2, code | 0x02);
893 i = 1;
894 } else {
895 i = 0;
896 last_non_zero = -1;
897 goto next_coef;
898 }
899 }
900
901 /* now quantify & encode AC coefs */
902 last_non_zero = i - 1;
80feb2a2 903
de6d9b64 904 for(;i<=last_index;i++) {
2ad1516a 905 j = s->intra_scantable.permutated[i];
de6d9b64
FB
906 level = block[j];
907 next_coef:
908#if 0
909 if (level != 0)
910 dprintf("level[%d]=%d\n", i, level);
911#endif
912 /* encode using VLC */
913 if (level != 0) {
914 run = i - last_non_zero - 1;
2ad1516a
MN
915
916 alevel= level;
917 MASK_ABS(sign, alevel)
918 sign&=1;
919
80feb2a2 920// code = get_rl_index(rl, 0, run, alevel);
c442d75c 921 if (alevel <= mpeg1_max_level[0][run]){
80feb2a2 922 code= mpeg1_index_run[0][run] + alevel - 1;
80feb2a2
MN
923 /* store the vlc & sign at once */
924 put_bits(&s->pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign);
de6d9b64 925 } else {
80feb2a2
MN
926 /* escape seems to be pretty rare <5% so i dont optimize it */
927 put_bits(&s->pb, mpeg1_vlc[111/*rl->n*/][1], mpeg1_vlc[111/*rl->n*/][0]);
de6d9b64
FB
928 /* escape: only clip in this case */
929 put_bits(&s->pb, 6, run);
029911d1
MN
930 if(s->codec_id == CODEC_ID_MPEG1VIDEO){
931 if (alevel < 128) {
932 put_bits(&s->pb, 8, level & 0xff);
de6d9b64 933 } else {
029911d1
MN
934 if (level < 0) {
935 put_bits(&s->pb, 16, 0x8001 + level + 255);
936 } else {
937 put_bits(&s->pb, 16, level & 0xffff);
938 }
de6d9b64 939 }
029911d1
MN
940 }else{
941 put_bits(&s->pb, 12, level & 0xfff);
de6d9b64
FB
942 }
943 }
944 last_non_zero = i;
945 }
946 }
947 /* end of block */
948 put_bits(&s->pb, 2, 0x2);
949}
7604246d 950#endif //CONFIG_ENCODERS
de6d9b64
FB
951
952/******************************************/
953/* decoding */
954
955static VLC dc_lum_vlc;
956static VLC dc_chroma_vlc;
957static VLC mv_vlc;
958static VLC mbincr_vlc;
959static VLC mb_ptype_vlc;
960static VLC mb_btype_vlc;
961static VLC mb_pat_vlc;
962
c3bf0288 963static void init_vlcs()
de6d9b64
FB
964{
965 static int done = 0;
966
967 if (!done) {
915bbac6 968 done = 1;
de6d9b64 969
9ac7ecd6 970 init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,
de6d9b64
FB
971 vlc_dc_lum_bits, 1, 1,
972 vlc_dc_lum_code, 2, 2);
9ac7ecd6 973 init_vlc(&dc_chroma_vlc, DC_VLC_BITS, 12,
de6d9b64
FB
974 vlc_dc_chroma_bits, 1, 1,
975 vlc_dc_chroma_code, 2, 2);
8ed2ddb2 976 init_vlc(&mv_vlc, MV_VLC_BITS, 17,
de6d9b64
FB
977 &mbMotionVectorTable[0][1], 2, 1,
978 &mbMotionVectorTable[0][0], 2, 1);
9c00c3af 979 init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36,
de6d9b64
FB
980 &mbAddrIncrTable[0][1], 2, 1,
981 &mbAddrIncrTable[0][0], 2, 1);
8ed2ddb2 982 init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63,
de6d9b64
FB
983 &mbPatTable[0][1], 2, 1,
984 &mbPatTable[0][0], 2, 1);
985
7bc9090a 986 init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
de6d9b64
FB
987 &table_mb_ptype[0][1], 2, 1,
988 &table_mb_ptype[0][0], 2, 1);
7bc9090a 989 init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
de6d9b64
FB
990 &table_mb_btype[0][1], 2, 1,
991 &table_mb_btype[0][0], 2, 1);
992 init_rl(&rl_mpeg1);
993 init_rl(&rl_mpeg2);
4f68b084
MN
994
995 init_2d_vlc_rl(&rl_mpeg1);
996 init_2d_vlc_rl(&rl_mpeg2);
de6d9b64
FB
997 }
998}
999
1000static inline int get_dmv(MpegEncContext *s)
1001{
612476ef
A
1002 if(get_bits1(&s->gb))
1003 return 1 - (get_bits1(&s->gb) << 1);
de6d9b64
FB
1004 else
1005 return 0;
1006}
1007
0ee50938
FB
1008static inline int get_qscale(MpegEncContext *s)
1009{
7062fad6 1010 int qscale = get_bits(&s->gb, 5);
029911d1 1011 if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
0ee50938 1012 if (s->q_scale_type) {
7062fad6 1013 return non_linear_qscale[qscale];
0ee50938 1014 } else {
7062fad6 1015 return qscale << 1;
0ee50938 1016 }
0ee50938
FB
1017 }
1018 return qscale;
1019}
1020
de6d9b64
FB
1021/* motion type (for mpeg2) */
1022#define MT_FIELD 1
1023#define MT_FRAME 2
1024#define MT_16X8 2
1025#define MT_DMV 3
1026
1027static int mpeg_decode_mb(MpegEncContext *s,
1028 DCTELEM block[6][64])
1029{
d2975f8d 1030 int i, j, k, cbp, val, mb_type, motion_type;
de6d9b64 1031
de6d9b64
FB
1032 dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
1033
f943e138
MN
1034 assert(s->mb_skiped==0);
1035
9b8709d1 1036 if (s->mb_skip_run-- != 0) {
7bc9090a 1037 if(s->pict_type == I_TYPE){
9b879566 1038 av_log(s->avctx, AV_LOG_ERROR, "skiped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
7bc9090a
MN
1039 return -1;
1040 }
1041
de6d9b64
FB
1042 /* skip mb */
1043 s->mb_intra = 0;
1044 for(i=0;i<6;i++)
1045 s->block_last_index[i] = -1;
1046 s->mv_type = MV_TYPE_16X16;
1047 if (s->pict_type == P_TYPE) {
1048 /* if P type, zero motion vector is implied */
1049 s->mv_dir = MV_DIR_FORWARD;
1050 s->mv[0][0][0] = s->mv[0][0][1] = 0;
1051 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
25ed7f92 1052 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
f943e138 1053 s->mb_skiped = 1;
7bc9090a 1054 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
de6d9b64
FB
1055 } else {
1056 /* if B type, reuse previous vectors and directions */
1057 s->mv[0][0][0] = s->last_mv[0][0][0];
1058 s->mv[0][0][1] = s->last_mv[0][0][1];
1059 s->mv[1][0][0] = s->last_mv[1][0][0];
1060 s->mv[1][0][1] = s->last_mv[1][0][1];
f943e138 1061
7bc9090a
MN
1062 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
1063 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1] | MB_TYPE_SKIP;
1064// assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
1065
f943e138
MN
1066 if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
1067 s->mb_skiped = 1;
de6d9b64 1068 }
59b571c1 1069
de6d9b64
FB
1070 return 0;
1071 }
1072
1073 switch(s->pict_type) {
1074 default:
1075 case I_TYPE:
612476ef 1076 if (get_bits1(&s->gb) == 0) {
e94bc100 1077 if (get_bits1(&s->gb) == 0){
9b879566 1078 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
de6d9b64 1079 return -1;
e94bc100 1080 }
7bc9090a 1081 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
de6d9b64 1082 } else {
7bc9090a 1083 mb_type = MB_TYPE_INTRA;
de6d9b64
FB
1084 }
1085 break;
1086 case P_TYPE:
8ed2ddb2 1087 mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
9ac7ecd6 1088 if (mb_type < 0){
9b879566 1089 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
de6d9b64 1090 return -1;
9ac7ecd6 1091 }
7bc9090a 1092 mb_type = ptype2mb_type[ mb_type ];
de6d9b64
FB
1093 break;
1094 case B_TYPE:
8ed2ddb2 1095 mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
9ac7ecd6 1096 if (mb_type < 0){
9b879566 1097 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
de6d9b64 1098 return -1;
9ac7ecd6 1099 }
7bc9090a 1100 mb_type = btype2mb_type[ mb_type ];
de6d9b64
FB
1101 break;
1102 }
1103 dprintf("mb_type=%x\n", mb_type);
7bc9090a
MN
1104// motion_type = 0; /* avoid warning */
1105 if (IS_INTRA(mb_type)) {
1106 /* compute dct type */
1107 if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1108 !s->frame_pred_frame_dct) {
1109 s->interlaced_dct = get_bits1(&s->gb);
1110 }
de6d9b64 1111
7bc9090a
MN
1112 if (IS_QUANT(mb_type))
1113 s->qscale = get_qscale(s);
1114
de6d9b64
FB
1115 if (s->concealment_motion_vectors) {
1116 /* just parse them */
1117 if (s->picture_structure != PICT_FRAME)
612476ef 1118 skip_bits1(&s->gb); /* field select */
daab3296
MN
1119
1120 s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
1121 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
1122 s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
1123 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
1124
7bc9090a 1125 skip_bits1(&s->gb); /* marker */
daab3296
MN
1126 }else
1127 memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
de6d9b64 1128 s->mb_intra = 1;
a579db0c
IK
1129#ifdef HAVE_XVMC
1130 //one 1 we memcpy blocks in xvmcvideo
1131 if(s->avctx->xvmc_acceleration > 1){
1132 XVMC_pack_pblocks(s,-1);//inter are always full blocks
1133 if(s->swap_uv){
1134 exchange_uv(s);
1135 }
1136 }
1137#endif
7bc9090a 1138
029911d1 1139 if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
7bc9090a 1140 for(i=0;i<6;i++) {
a579db0c 1141 if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
7bc9090a
MN
1142 return -1;
1143 }
1144 } else {
1145 for(i=0;i<6;i++) {
a579db0c 1146 if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
7bc9090a
MN
1147 return -1;
1148 }
1149 }
de6d9b64 1150 } else {
7bc9090a 1151 if (mb_type & MB_TYPE_ZERO_MV){
b40cd4e0 1152 assert(mb_type & MB_TYPE_CBP);
7bc9090a
MN
1153
1154 /* compute dct type */
1155 if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
1156 !s->frame_pred_frame_dct) {
1157 s->interlaced_dct = get_bits1(&s->gb);
1158 }
1159
1160 if (IS_QUANT(mb_type))
1161 s->qscale = get_qscale(s);
1162
1163 s->mv_dir = MV_DIR_FORWARD;
1164 s->mv_type = MV_TYPE_16X16;
1165 s->last_mv[0][0][0] = 0;
1166 s->last_mv[0][0][1] = 0;
1167 s->last_mv[0][1][0] = 0;
1168 s->last_mv[0][1][1] = 0;
1169 s->mv[0][0][0] = 0;
1170 s->mv[0][0][1] = 0;
1171 }else{
1172 assert(mb_type & MB_TYPE_L0L1);
1173//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
1174 /* get additionnal motion vector type */
1175 if (s->frame_pred_frame_dct)
1176 motion_type = MT_FRAME;
1177 else{
1178 motion_type = get_bits(&s->gb, 2);
1179 }
1180
1181 /* compute dct type */
1182 if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
b40cd4e0 1183 !s->frame_pred_frame_dct && HAS_CBP(mb_type)) {
7bc9090a
MN
1184 s->interlaced_dct = get_bits1(&s->gb);
1185 }
1186
1187 if (IS_QUANT(mb_type))
1188 s->qscale = get_qscale(s);
1189
1190 /* motion vectors */
1191 s->mv_dir = 0;
1192 for(i=0;i<2;i++) {
1193 if (USES_LIST(mb_type, i)) {
1194 s->mv_dir |= (MV_DIR_FORWARD >> i);
1195 dprintf("motion_type=%d\n", motion_type);
1196 switch(motion_type) {
1197 case MT_FRAME: /* or MT_16X8 */
1198 if (s->picture_structure == PICT_FRAME) {
1199 /* MT_FRAME */
1200 mb_type |= MB_TYPE_16x16;
1201 s->mv_type = MV_TYPE_16X16;
1202 s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
1203 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
1204 s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
1205 mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
de6d9b64 1206 /* full_pel: only for mpeg1 */
7bc9090a
MN
1207 if (s->full_pel[i]){
1208 s->mv[i][0][0] <<= 1;
1209 s->mv[i][0][1] <<= 1;
1210 }
1211 } else {
1212 /* MT_16X8 */
26f548a7 1213 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
7bc9090a
MN
1214 s->mv_type = MV_TYPE_16X8;
1215 for(j=0;j<2;j++) {
1216 s->field_select[i][j] = get_bits1(&s->gb);
1217 for(k=0;k<2;k++) {
1218 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
1219 s->last_mv[i][j][k]);
1220 s->last_mv[i][j][k] = val;
1221 s->mv[i][j][k] = val;
1222 }
1223 }
de6d9b64 1224 }
7bc9090a
MN
1225 break;
1226 case MT_FIELD:
1227 s->mv_type = MV_TYPE_FIELD;
1228 if (s->picture_structure == PICT_FRAME) {
1229 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1230 for(j=0;j<2;j++) {
1231 s->field_select[i][j] = get_bits1(&s->gb);
1232 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1233 s->last_mv[i][j][0]);
1234 s->last_mv[i][j][0] = val;
1235 s->mv[i][j][0] = val;
1236 dprintf("fmx=%d\n", val);
1237 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1238 s->last_mv[i][j][1] >> 1);
1239 s->last_mv[i][j][1] = val << 1;
1240 s->mv[i][j][1] = val;
1241 dprintf("fmy=%d\n", val);
1242 }
1243 } else {
26f548a7 1244 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
7bc9090a 1245 s->field_select[i][0] = get_bits1(&s->gb);
de6d9b64
FB
1246 for(k=0;k<2;k++) {
1247 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
7bc9090a
MN
1248 s->last_mv[i][0][k]);
1249 s->last_mv[i][0][k] = val;
1250 s->last_mv[i][1][k] = val;
1251 s->mv[i][0][k] = val;
de6d9b64
FB
1252 }
1253 }
7bc9090a
MN
1254 break;
1255 case MT_DMV:
1256 {
1257 int dmx, dmy, mx, my, m;
1258
1259 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
1260 s->last_mv[i][0][0]);
1261 s->last_mv[i][0][0] = mx;
1262 s->last_mv[i][1][0] = mx;
1263 dmx = get_dmv(s);
1264 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
1265 s->last_mv[i][0][1] >> 1);
1266 dmy = get_dmv(s);
1267 s->mv_type = MV_TYPE_DMV;
1dff7d56
IK
1268
1269
1270 s->last_mv[i][0][1] = my<<1;
1271 s->last_mv[i][1][1] = my<<1;
1272
1273 s->mv[i][0][0] = mx;
1274 s->mv[i][0][1] = my;
1275 s->mv[i][1][0] = mx;//not used
1276 s->mv[i][1][1] = my;//not used
1277
7bc9090a
MN
1278 if (s->picture_structure == PICT_FRAME) {
1279 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
1280
1dff7d56 1281 //m = 1 + 2 * s->top_field_first;
7bc9090a 1282 m = s->top_field_first ? 1 : 3;
1dff7d56 1283
7bc9090a 1284 /* top -> top pred */
1dff7d56
IK
1285 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1286 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
7bc9090a 1287 m = 4 - m;
7bc9090a
MN
1288 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1289 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1290 } else {
1291 mb_type |= MB_TYPE_16x16;
1292
1dff7d56
IK
1293 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1294 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1295 if(s->picture_structure == PICT_TOP_FIELD)
1296 s->mv[i][2][1]--;
1297 else
1298 s->mv[i][2][1]++;
7bc9090a 1299 }
de6d9b64 1300 }
7bc9090a 1301 break;
26f548a7
MN
1302 default:
1303 av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
1304 return -1;
de6d9b64 1305 }
de6d9b64
FB
1306 }
1307 }
1308 }
7bc9090a
MN
1309
1310 s->mb_intra = 0;
de6d9b64 1311
b40cd4e0 1312 if (HAS_CBP(mb_type)) {
7bc9090a
MN
1313 cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1314 if (cbp < 0){
9b879566 1315 av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
7bc9090a 1316 return -1;
de6d9b64 1317 }
7bc9090a
MN
1318 cbp++;
1319
a579db0c
IK
1320#ifdef HAVE_XVMC
1321 //on 1 we memcpy blocks in xvmcvideo
1322 if(s->avctx->xvmc_acceleration > 1){
1323 XVMC_pack_pblocks(s,cbp);
1324 if(s->swap_uv){
1325 exchange_uv(s);
1326 }
1327 }
1328#endif
1329
029911d1 1330 if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
7bc9090a
MN
1331 for(i=0;i<6;i++) {
1332 if (cbp & 32) {
a579db0c 1333 if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
7bc9090a
MN
1334 return -1;
1335 } else {
1336 s->block_last_index[i] = -1;
1337 }
1338 cbp+=cbp;
de6d9b64 1339 }
7bc9090a
MN
1340 } else {
1341 for(i=0;i<6;i++) {
1342 if (cbp & 32) {
a579db0c 1343 if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
7bc9090a
MN
1344 return -1;
1345 } else {
1346 s->block_last_index[i] = -1;
1347 }
1348 cbp+=cbp;
a0201736 1349 }
de6d9b64 1350 }
7bc9090a
MN
1351 }else{
1352 for(i=0;i<6;i++)
1353 s->block_last_index[i] = -1;
de6d9b64
FB
1354 }
1355 }
7bc9090a
MN
1356
1357 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
1358
de6d9b64
FB
1359 return 0;
1360}
1361
1362/* as h263, but only 17 codes */
1363static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
1364{
05858889 1365 int code, sign, val, l, shift;
de6d9b64 1366
8ed2ddb2 1367 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
de6d9b64
FB
1368 if (code == 0) {
1369 return pred;
1370 }
7bc9090a
MN
1371 if (code < 0) {
1372 return 0xffff;
1373 }
1374
612476ef 1375 sign = get_bits1(&s->gb);
de6d9b64 1376 shift = fcode - 1;
05858889
B
1377 val = code;
1378 if (shift) {
1379 val = (val - 1) << shift;
de6d9b64 1380 val |= get_bits(&s->gb, shift);
05858889
B
1381 val++;
1382 }
de6d9b64
FB
1383 if (sign)
1384 val = -val;
1385 val += pred;
1386
1387 /* modulo decoding */
7bc9090a 1388 l = 1 << (shift+4);
05858889 1389 val = ((val + l)&(l*2-1)) - l;
de6d9b64
FB
1390 return val;
1391}
1392
c3bf0288 1393static inline int decode_dc(GetBitContext *gb, int component)
de6d9b64
FB
1394{
1395 int code, diff;
1396
1397 if (component == 0) {
c3bf0288 1398 code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
de6d9b64 1399 } else {
c3bf0288 1400 code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
de6d9b64 1401 }
9ac7ecd6 1402 if (code < 0){
9b879566 1403 av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
de6d9b64 1404 return 0xffff;
9ac7ecd6 1405 }
de6d9b64
FB
1406 if (code == 0) {
1407 diff = 0;
1408 } else {
c3bf0288 1409 diff = get_xbits(gb, code);
de6d9b64
FB
1410 }
1411 return diff;
1412}
1413
a0201736 1414static inline int mpeg1_decode_block_intra(MpegEncContext *s,
de6d9b64
FB
1415 DCTELEM *block,
1416 int n)
1417{
1418 int level, dc, diff, i, j, run;
a0201736 1419 int component;
de6d9b64 1420 RLTable *rl = &rl_mpeg1;
0c1a9eda
ZK
1421 uint8_t * const scantable= s->intra_scantable.permutated;
1422 const uint16_t *quant_matrix= s->intra_matrix;
a0201736 1423 const int qscale= s->qscale;
de6d9b64 1424
a0201736
MN
1425 /* DC coef */
1426 component = (n <= 3 ? 0 : n - 4 + 1);
c3bf0288 1427 diff = decode_dc(&s->gb, component);
a0201736
MN
1428 if (diff >= 0xffff)
1429 return -1;
1430 dc = s->last_dc[component];
1431 dc += diff;
1432 s->last_dc[component] = dc;
1433 block[0] = dc<<3;
1434 dprintf("dc=%d diff=%d\n", dc, diff);
1435 i = 0;
1436 {
1437 OPEN_READER(re, &s->gb);
1438 /* now quantify & encode AC coefs */
1439 for(;;) {
1440 UPDATE_CACHE(re, &s->gb);
1441 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1442
1443 if(level == 127){
1444 break;
1445 } else if(level != 0) {
1446 i += run;
1447 j = scantable[i];
1448 level= (level*qscale*quant_matrix[j])>>3;
1449 level= (level-1)|1;
1450 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1451 LAST_SKIP_BITS(re, &s->gb, 1);
1452 } else {
1453 /* escape */
1454 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1455 UPDATE_CACHE(re, &s->gb);
1456 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1457 if (level == -128) {
1458 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1459 } else if (level == 0) {
1460 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8);
1461 }
1462 i += run;
1463 j = scantable[i];
1464 if(level<0){
1465 level= -level;
1466 level= (level*qscale*quant_matrix[j])>>3;
1467 level= (level-1)|1;
1468 level= -level;
1469 }else{
1470 level= (level*qscale*quant_matrix[j])>>3;
1471 level= (level-1)|1;
1472 }
1473 }
1474 if (i > 63){
9b879566 1475 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
a0201736
MN
1476 return -1;
1477 }
1478
1479 block[j] = level;
1480 }
1481 CLOSE_READER(re, &s->gb);
1482 }
1483 s->block_last_index[n] = i;
1484 return 0;
1485}
1486
1487static inline int mpeg1_decode_block_inter(MpegEncContext *s,
1488 DCTELEM *block,
1489 int n)
1490{
1491 int level, i, j, run;
1492 RLTable *rl = &rl_mpeg1;
0c1a9eda
ZK
1493 uint8_t * const scantable= s->intra_scantable.permutated;
1494 const uint16_t *quant_matrix= s->inter_matrix;
a0201736
MN
1495 const int qscale= s->qscale;
1496
1497 {
8db1a1dd
MN
1498 int v;
1499 OPEN_READER(re, &s->gb);
a0201736 1500 i = -1;
de6d9b64 1501 /* special case for the first coef. no need to add a second vlc table */
8db1a1dd
MN
1502 UPDATE_CACHE(re, &s->gb);
1503 v= SHOW_UBITS(re, &s->gb, 2);
de6d9b64 1504 if (v & 2) {
3729c912 1505 LAST_SKIP_BITS(re, &s->gb, 2);
a0201736
MN
1506 level= (3*qscale*quant_matrix[0])>>4;
1507 level= (level-1)|1;
1508 if(v&1)
1509 level= -level;
3729c912 1510 block[0] = level;
a0201736 1511 i++;
de6d9b64 1512 }
3729c912 1513
a0201736
MN
1514 /* now quantify & encode AC coefs */
1515 for(;;) {
1516 UPDATE_CACHE(re, &s->gb);
1517 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1518
1519 if(level == 127){
1520 break;
1521 } else if(level != 0) {
1522 i += run;
1523 j = scantable[i];
1524 level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1525 level= (level-1)|1;
1526 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1527 LAST_SKIP_BITS(re, &s->gb, 1);
1528 } else {
1529 /* escape */
1530 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1531 UPDATE_CACHE(re, &s->gb);
1532 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
1533 if (level == -128) {
1534 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
1535 } else if (level == 0) {
1536 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8);
1537 }
1538 i += run;
1539 j = scantable[i];
1540 if(level<0){
1541 level= -level;
1542 level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1543 level= (level-1)|1;
1544 level= -level;
1545 }else{
1546 level= ((level*2+1)*qscale*quant_matrix[j])>>4;
1547 level= (level-1)|1;
1548 }
de6d9b64 1549 }
a0201736 1550 if (i > 63){
9b879566 1551 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
a0201736
MN
1552 return -1;
1553 }
1554
1555 block[j] = level;
de6d9b64 1556 }
a0201736 1557 CLOSE_READER(re, &s->gb);
de6d9b64 1558 }
a0201736 1559 s->block_last_index[n] = i;
de6d9b64
FB
1560 return 0;
1561}
1562
1563/* Also does unquantization here, since I will never support mpeg2
1564 encoding */
3729c912
MN
1565static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
1566 DCTELEM *block,
1567 int n)
de6d9b64
FB
1568{
1569 int level, i, j, run;
de6d9b64 1570 RLTable *rl = &rl_mpeg1;
0c1a9eda
ZK
1571 uint8_t * const scantable= s->intra_scantable.permutated;
1572 const uint16_t *quant_matrix;
3729c912 1573 const int qscale= s->qscale;
de6d9b64
FB
1574 int mismatch;
1575
de6d9b64
FB
1576 mismatch = 1;
1577
1578 {
8db1a1dd
MN
1579 int v;
1580 OPEN_READER(re, &s->gb);
3729c912 1581 i = -1;
8db1a1dd 1582 if (n < 4)
3729c912 1583 quant_matrix = s->inter_matrix;
de6d9b64 1584 else
3729c912 1585 quant_matrix = s->chroma_inter_matrix;
8db1a1dd 1586
de6d9b64 1587 /* special case for the first coef. no need to add a second vlc table */
8db1a1dd
MN
1588 UPDATE_CACHE(re, &s->gb);
1589 v= SHOW_UBITS(re, &s->gb, 2);
de6d9b64 1590 if (v & 2) {
3729c912
MN
1591 LAST_SKIP_BITS(re, &s->gb, 2);
1592 level= (3*qscale*quant_matrix[0])>>5;
1593 if(v&1)
1594 level= -level;
1595 block[0] = level;
1596 mismatch ^= level;
1597 i++;
de6d9b64 1598 }
de6d9b64 1599
3729c912
MN
1600 /* now quantify & encode AC coefs */
1601 for(;;) {
1602 UPDATE_CACHE(re, &s->gb);
1603 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1604
1605 if(level == 127){
1606 break;
1607 } else if(level != 0) {
1608 i += run;
1609 j = scantable[i];
1610 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1611 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1612 LAST_SKIP_BITS(re, &s->gb, 1);
1613 } else {
1614 /* escape */
1615 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1616 UPDATE_CACHE(re, &s->gb);
1617 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1618
1619 i += run;
1620 j = scantable[i];
1621 if(level<0){
1622 level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
1623 level= -level;
1624 }else{
1625 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
1626 }
1627 }
1628 if (i > 63){
9b879566 1629 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3729c912
MN
1630 return -1;
1631 }
1632
1633 mismatch ^= level;
1634 block[j] = level;
25ed7f92 1635 }
3729c912 1636 CLOSE_READER(re, &s->gb);
de6d9b64
FB
1637 }
1638 block[63] ^= (mismatch & 1);
3729c912 1639
de6d9b64
FB
1640 s->block_last_index[n] = i;
1641 return 0;
1642}
1643
3729c912
MN
1644static inline int mpeg2_decode_block_intra(MpegEncContext *s,
1645 DCTELEM *block,
1646 int n)
de6d9b64
FB
1647{
1648 int level, dc, diff, i, j, run;
3729c912 1649 int component;
de6d9b64 1650 RLTable *rl;
0c1a9eda
ZK
1651 uint8_t * const scantable= s->intra_scantable.permutated;
1652 const uint16_t *quant_matrix;
3729c912 1653 const int qscale= s->qscale;
de6d9b64
FB
1654 int mismatch;
1655
de6d9b64 1656 /* DC coef */
3729c912
MN
1657 if (n < 4){
1658 quant_matrix = s->intra_matrix;
1659 component = 0;
1660 }else{
1661 quant_matrix = s->chroma_intra_matrix;
1662 component = n - 3;
1663 }
c3bf0288 1664 diff = decode_dc(&s->gb, component);
de6d9b64
FB
1665 if (diff >= 0xffff)
1666 return -1;
1667 dc = s->last_dc[component];
1668 dc += diff;
1669 s->last_dc[component] = dc;
1670 block[0] = dc << (3 - s->intra_dc_precision);
1671 dprintf("dc=%d\n", block[0]);
d753173a 1672 mismatch = block[0] ^ 1;
3729c912 1673 i = 0;
de6d9b64
FB
1674 if (s->intra_vlc_format)
1675 rl = &rl_mpeg2;
1676 else
1677 rl = &rl_mpeg1;
25ed7f92 1678
3729c912
MN
1679 {
1680 OPEN_READER(re, &s->gb);
1681 /* now quantify & encode AC coefs */
1682 for(;;) {
1683 UPDATE_CACHE(re, &s->gb);
1684 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2);
1685
1686 if(level == 127){
1687 break;
1688 } else if(level != 0) {
1689 i += run;
1690 j = scantable[i];
1691 level= (level*qscale*quant_matrix[j])>>4;
1692 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1693 LAST_SKIP_BITS(re, &s->gb, 1);
1694 } else {
1695 /* escape */
1696 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1697 UPDATE_CACHE(re, &s->gb);
1698 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1699 i += run;
1700 j = scantable[i];
1701 if(level<0){
1702 level= (-level*qscale*quant_matrix[j])>>4;
1703 level= -level;
1704 }else{
1705 level= (level*qscale*quant_matrix[j])>>4;
1706 }
1707 }
1708 if (i > 63){
9b879566 1709 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
3729c912
MN
1710 return -1;
1711 }
1712
1713 mismatch^= level;
1714 block[j] = level;
9ac7ecd6 1715 }
3729c912 1716 CLOSE_READER(re, &s->gb);
de6d9b64 1717 }
3729c912
MN
1718 block[63]^= mismatch&1;
1719
de6d9b64
FB
1720 s->block_last_index[n] = i;
1721 return 0;
1722}
1723
de6d9b64
FB
1724typedef struct Mpeg1Context {
1725 MpegEncContext mpeg_enc_ctx;
de6d9b64 1726 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1cb0edb4 1727 int repeat_field; /* true if we must repeat the field */
fa384dcc 1728 AVPanScan pan_scan; /** some temporary storage for the panscan */
de6d9b64
FB
1729} Mpeg1Context;
1730
1731static int mpeg_decode_init(AVCodecContext *avctx)
1732{
1733 Mpeg1Context *s = avctx->priv_data;
8f8402e4 1734
94aec31f 1735 s->mpeg_enc_ctx.flags= avctx->flags;
8f8402e4 1736 common_init(&s->mpeg_enc_ctx);
c3bf0288 1737 init_vlcs();
de6d9b64 1738
de6d9b64 1739 s->mpeg_enc_ctx_allocated = 0;
de6d9b64 1740 s->mpeg_enc_ctx.picture_number = 0;
1cb0edb4 1741 s->repeat_field = 0;
d7e9533a 1742 s->mpeg_enc_ctx.codec_id= avctx->codec->id;
de6d9b64
FB
1743 return 0;
1744}
1745
1746/* return the 8 bit start code value and update the search
1747 state. Return -1 if no start code found */
80097bbf 1748static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end)
de6d9b64 1749{
0c1a9eda 1750 uint8_t *buf_ptr;
80097bbf 1751 unsigned int state=0xFFFFFFFF, v;
de6d9b64
FB
1752 int val;
1753
de6d9b64
FB
1754 buf_ptr = *pbuf_ptr;
1755 while (buf_ptr < buf_end) {
1756 v = *buf_ptr++;
1757 if (state == 0x000001) {
1758 state = ((state << 8) | v) & 0xffffff;
1759 val = state;
1760 goto found;
1761 }
1762 state = ((state << 8) | v) & 0xffffff;
1763 }
1764 val = -1;
1765 found:
1766 *pbuf_ptr = buf_ptr;
de6d9b64
FB
1767 return val;
1768}
1769
1770static int mpeg1_decode_picture(AVCodecContext *avctx,
0c1a9eda 1771 uint8_t *buf, int buf_size)
de6d9b64
FB
1772{
1773 Mpeg1Context *s1 = avctx->priv_data;
1774 MpegEncContext *s = &s1->mpeg_enc_ctx;
d60a8f85 1775 int ref, f_code, vbv_delay;
de6d9b64 1776
68f593b4 1777 init_get_bits(&s->gb, buf, buf_size*8);
de6d9b64
FB
1778
1779 ref = get_bits(&s->gb, 10); /* temporal ref */
1780 s->pict_type = get_bits(&s->gb, 3);
b9ecd1ee 1781 dprintf("pict_type=%d number=%d\n", s->pict_type, s->picture_number);
58bfafbe 1782
d60a8f85 1783 vbv_delay= get_bits(&s->gb, 16);
de6d9b64 1784 if (s->pict_type == P_TYPE || s->pict_type == B_TYPE) {
612476ef 1785 s->full_pel[0] = get_bits1(&s->gb);
de6d9b64
FB
1786 f_code = get_bits(&s->gb, 3);
1787 if (f_code == 0)
1788 return -1;
1789 s->mpeg_f_code[0][0] = f_code;
1790 s->mpeg_f_code[0][1] = f_code;
1791 }
1792 if (s->pict_type == B_TYPE) {
612476ef 1793 s->full_pel[1] = get_bits1(&s->gb);
de6d9b64
FB
1794 f_code = get_bits(&s->gb, 3);
1795 if (f_code == 0)
1796 return -1;
1797 s->mpeg_f_code[1][0] = f_code;
1798 s->mpeg_f_code[1][1] = f_code;
1799 }
1e491e29
MN
1800 s->current_picture.pict_type= s->pict_type;
1801 s->current_picture.key_frame= s->pict_type == I_TYPE;
d9cb5429 1802
de6d9b64
FB
1803 s->y_dc_scale = 8;
1804 s->c_dc_scale = 8;
1805 s->first_slice = 1;
1806 return 0;
1807}
1808
1809static void mpeg_decode_sequence_extension(MpegEncContext *s)
1810{
1811 int horiz_size_ext, vert_size_ext;
945f15b7 1812 int bit_rate_ext, vbv_buf_ext;
de6d9b64 1813 int frame_rate_ext_n, frame_rate_ext_d;
029911d1 1814 int level, profile;
de6d9b64 1815
029911d1
MN
1816 skip_bits(&s->gb, 1); /* profil and level esc*/
1817 profile= get_bits(&s->gb, 3);
1818 level= get_bits(&s->gb, 4);
1cb0edb4 1819 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
612476ef 1820 skip_bits(&s->gb, 2); /* chroma_format */
de6d9b64
FB
1821 horiz_size_ext = get_bits(&s->gb, 2);
1822 vert_size_ext = get_bits(&s->gb, 2);
1823 s->width |= (horiz_size_ext << 12);
1824 s->height |= (vert_size_ext << 12);
1825 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1826 s->bit_rate = ((s->bit_rate / 400) | (bit_rate_ext << 12)) * 400;
612476ef 1827 skip_bits1(&s->gb); /* marker */
de6d9b64 1828 vbv_buf_ext = get_bits(&s->gb, 8);
e0560448 1829
945f15b7 1830 s->low_delay = get_bits1(&s->gb);
e0560448
MN
1831 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1832
de6d9b64
FB
1833 frame_rate_ext_n = get_bits(&s->gb, 2);
1834 frame_rate_ext_d = get_bits(&s->gb, 5);
14bea432
MN
1835 av_reduce(
1836 &s->avctx->frame_rate,
1837 &s->avctx->frame_rate_base,
1838 frame_rate_tab[s->frame_rate_index] * (frame_rate_ext_n+1),
1839 MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),
1840 1<<30);
1841
de6d9b64 1842 dprintf("sequence extension\n");
029911d1 1843 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
fb4a4a56 1844 s->avctx->sub_id = 2; /* indicates mpeg2 found */
945f15b7 1845
5ff85f1d
MN
1846 if(s->aspect_ratio_info <= 1)
1847 s->avctx->sample_aspect_ratio= mpeg2_aspect[s->aspect_ratio_info];
1848 else{
1849 s->avctx->sample_aspect_ratio=
1850 av_div_q(
1851 mpeg2_aspect[s->aspect_ratio_info],
1852 (AVRational){s->width, s->height}
1853 );
1854 }
029911d1
MN
1855
1856 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
9b879566 1857 av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d \n", profile, level);
de6d9b64
FB
1858}
1859
fa384dcc
MN
1860static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1861{
1862 MpegEncContext *s= &s1->mpeg_enc_ctx;
1863 int color_description, w, h;
1864
1865 skip_bits(&s->gb, 3); /* video format */
1866 color_description= get_bits1(&s->gb);
1867 if(color_description){
1868 skip_bits(&s->gb, 8); /* color primaries */
1869 skip_bits(&s->gb, 8); /* transfer_characteristics */
1870 skip_bits(&s->gb, 8); /* matrix_coefficients */
1871 }
1872 w= get_bits(&s->gb, 14);
1873 skip_bits(&s->gb, 1); //marker
1874 h= get_bits(&s->gb, 14);
1875 skip_bits(&s->gb, 1); //marker
1876
1877 s1->pan_scan.width= 16*w;
1878 s1->pan_scan.height=16*h;
1879
5ff85f1d
MN
1880 if(s->aspect_ratio_info > 1)
1881 s->avctx->sample_aspect_ratio=
1882 av_div_q(
1883 mpeg2_aspect[s->aspect_ratio_info],
1884 (AVRational){w, h}
1885 );
fa384dcc
MN
1886
1887 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
9b879566 1888 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
fa384dcc
MN
1889}
1890
1891static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1892{
1893 MpegEncContext *s= &s1->mpeg_enc_ctx;
1894 int i;
1895
1896 for(i=0; i<1; i++){ //FIXME count
1897 s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16);
1898 skip_bits(&s->gb, 1); //marker
1899 s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16);
1900 skip_bits(&s->gb, 1); //marker
1901 }
1902
1903 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
9b879566 1904 av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n",
fa384dcc
MN
1905 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1906 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1907 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]
1908 );
1909}
1910
de6d9b64
FB
1911static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1912{
60832448 1913 int i, v, j;
de6d9b64 1914
25ed7f92
FB
1915 dprintf("matrix extension\n");
1916
612476ef 1917 if (get_bits1(&s->gb)) {
de6d9b64
FB
1918 for(i=0;i<64;i++) {
1919 v = get_bits(&s->gb, 8);
b0368839 1920 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
60832448
FB
1921 s->intra_matrix[j] = v;
1922 s->chroma_intra_matrix[j] = v;
de6d9b64
FB
1923 }
1924 }
612476ef 1925 if (get_bits1(&s->gb)) {
de6d9b64
FB
1926 for(i=0;i<64;i++) {
1927 v = get_bits(&s->gb, 8);
b0368839 1928 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
d7e9533a
MN
1929 s->inter_matrix[j] = v;
1930 s->chroma_inter_matrix[j] = v;
de6d9b64
FB
1931 }
1932 }
612476ef 1933 if (get_bits1(&s->gb)) {
de6d9b64
FB
1934 for(i=0;i<64;i++) {
1935 v = get_bits(&s->gb, 8);
b0368839 1936 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
60832448 1937 s->chroma_intra_matrix[j] = v;
de6d9b64
FB
1938 }
1939 }
612476ef 1940 if (get_bits1(&s->gb)) {
de6d9b64
FB
1941 for(i=0;i<64;i++) {
1942 v = get_bits(&s->gb, 8);
b0368839 1943 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
d7e9533a 1944 s->chroma_inter_matrix[j] = v;
de6d9b64
FB
1945 }
1946 }
1947}
1948
1949static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1950{
1951 s->full_pel[0] = s->full_pel[1] = 0;
1952 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1953 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1954 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1955 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1956 s->intra_dc_precision = get_bits(&s->gb, 2);
1957 s->picture_structure = get_bits(&s->gb, 2);
612476ef
A
1958 s->top_field_first = get_bits1(&s->gb);
1959 s->frame_pred_frame_dct = get_bits1(&s->gb);
1960 s->concealment_motion_vectors = get_bits1(&s->gb);
1961 s->q_scale_type = get_bits1(&s->gb);
1962 s->intra_vlc_format = get_bits1(&s->gb);
1963 s->alternate_scan = get_bits1(&s->gb);
1964 s->repeat_first_field = get_bits1(&s->gb);
1965 s->chroma_420_type = get_bits1(&s->gb);
1966 s->progressive_frame = get_bits1(&s->gb);
bb198e19 1967
dfb476cb
MN
1968 if(s->picture_structure == PICT_FRAME)
1969 s->first_field=0;
1970 else{
1971 s->first_field ^= 1;
7bc9090a 1972 memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
dfb476cb
MN
1973 }
1974
acf44abb 1975 if(s->alternate_scan){
3d2e8cce
MN
1976 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
1977 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
acf44abb 1978 }else{
3d2e8cce
MN
1979 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
1980 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
acf44abb
MN
1981 }
1982
de6d9b64 1983 /* composite display not parsed */
1cb0edb4 1984 dprintf("intra_dc_precision=%d\n", s->intra_dc_precision);
25ed7f92 1985 dprintf("picture_structure=%d\n", s->picture_structure);
e0a3d744
J
1986 dprintf("top field first=%d\n", s->top_field_first);
1987 dprintf("repeat first field=%d\n", s->repeat_first_field);
de6d9b64 1988 dprintf("conceal=%d\n", s->concealment_motion_vectors);
25ed7f92
FB
1989 dprintf("intra_vlc_format=%d\n", s->intra_vlc_format);
1990 dprintf("alternate_scan=%d\n", s->alternate_scan);
de6d9b64 1991 dprintf("frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1cb0edb4 1992 dprintf("progressive_frame=%d\n", s->progressive_frame);
de6d9b64
FB
1993}
1994
1995static void mpeg_decode_extension(AVCodecContext *avctx,
0c1a9eda 1996 uint8_t *buf, int buf_size)
de6d9b64
FB
1997{
1998 Mpeg1Context *s1 = avctx->priv_data;
1999 MpegEncContext *s = &s1->mpeg_enc_ctx;
2000 int ext_type;
2001
68f593b4 2002 init_get_bits(&s->gb, buf, buf_size*8);
de6d9b64
FB
2003
2004 ext_type = get_bits(&s->gb, 4);
2005 switch(ext_type) {
2006 case 0x1:
de6d9b64
FB
2007 mpeg_decode_sequence_extension(s);
2008 break;
fa384dcc
MN
2009 case 0x2:
2010 mpeg_decode_sequence_display_extension(s1);
2011 break;
de6d9b64 2012 case 0x3:
de6d9b64
FB
2013 mpeg_decode_quant_matrix_extension(s);
2014 break;
fa384dcc
MN
2015 case 0x7:
2016 mpeg_decode_picture_display_extension(s1);
2017 break;
de6d9b64 2018 case 0x8:
de6d9b64
FB
2019 mpeg_decode_picture_coding_extension(s);
2020 break;
2021 }
2022}
2023
a579db0c
IK
2024static void exchange_uv(MpegEncContext *s){
2025short * tmp;
2026
2027 tmp = s->pblocks[4];
2028 s->pblocks[4] = s->pblocks[5];
2029 s->pblocks[5] = tmp;
ff862be5
MN
2030}
2031
86f85dca
MN
2032#define DECODE_SLICE_FATAL_ERROR -2
2033#define DECODE_SLICE_ERROR -1
2034#define DECODE_SLICE_OK 0
86f85dca
MN
2035
2036/**
2037 * decodes a slice.
2038 * @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>
2039 * DECODE_SLICE_ERROR if the slice is damaged<br>
2040 * DECODE_SLICE_OK if this slice is ok<br>
86f85dca 2041 */
de6d9b64 2042static int mpeg_decode_slice(AVCodecContext *avctx,
492cd3a9 2043 AVFrame *pict,
de6d9b64 2044 int start_code,
80097bbf 2045 uint8_t **buf, int buf_size)
de6d9b64
FB
2046{
2047 Mpeg1Context *s1 = avctx->priv_data;
2048 MpegEncContext *s = &s1->mpeg_enc_ctx;
2049 int ret;
dfb476cb 2050 const int field_pic= s->picture_structure != PICT_FRAME;
de6d9b64 2051
db6e7795
MN
2052 s->resync_mb_x= s->mb_x =
2053 s->resync_mb_y= s->mb_y = -1;
2054
de6d9b64 2055 start_code = (start_code - 1) & 0xff;
9ac7ecd6 2056 if (start_code >= s->mb_height){
9b879566 2057 av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", start_code, s->mb_height);
db6e7795 2058 return -1;
9ac7ecd6 2059 }
9b8709d1
MN
2060
2061 ff_mpeg1_clean_buffers(s);
7bc9090a 2062 s->interlaced_dct = 0;
dfb476cb 2063
de6d9b64 2064 /* start frame decoding */
b536d0aa
MN
2065 if (s->first_slice) {
2066 if(s->first_field || s->picture_structure==PICT_FRAME){
d6db1c9c 2067 if(MPV_frame_start(s, avctx) < 0)
86f85dca 2068 return DECODE_SLICE_FATAL_ERROR;
7bc9090a
MN
2069
2070 ff_er_frame_start(s);
2071
2ec23b6d 2072 /* first check if we must repeat the frame */
9ee2c20e 2073 s->current_picture_ptr->repeat_pict = 0;
2ec23b6d
MN
2074 if (s->repeat_first_field) {
2075 if (s->progressive_sequence) {
2076 if (s->top_field_first)
9ee2c20e 2077 s->current_picture_ptr->repeat_pict = 4;
2ec23b6d 2078 else
9ee2c20e 2079 s->current_picture_ptr->repeat_pict = 2;
2ec23b6d 2080 } else if (s->progressive_frame) {
9ee2c20e 2081 s->current_picture_ptr->repeat_pict = 1;
2ec23b6d
MN
2082 }
2083 }
fa384dcc
MN
2084
2085 *s->current_picture_ptr->pan_scan= s1->pan_scan;
b536d0aa
MN
2086 }else{ //second field
2087 int i;
37b787f1
MN
2088
2089 if(!s->current_picture_ptr){
9b879566 2090 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
37b787f1
MN
2091 return -1;
2092 }
2093
b536d0aa
MN
2094 for(i=0; i<4; i++){
2095 s->current_picture.data[i] = s->current_picture_ptr->data[i];
2096 if(s->picture_structure == PICT_BOTTOM_FIELD){
2097 s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
2098 }
2099 }
2100 }
2e7b4c84
IK
2101#ifdef HAVE_XVMC
2102// MPV_frame_start will call this function too,
2103// but we need to call it on every field
2104 if(s->avctx->xvmc_acceleration)
2105 XVMC_field_start(s,avctx);
2106#endif
2107 }//fi(s->first_slice)
de6d9b64 2108
80097bbf 2109 init_get_bits(&s->gb, *buf, buf_size*8);
de6d9b64 2110
0ee50938 2111 s->qscale = get_qscale(s);
a4337a51
MN
2112 if (s->first_slice && (s->first_field || s->picture_structure==PICT_FRAME)) {
2113 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
bb198e19 2114 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%2d%2d%2d%2d %s %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
a4337a51
MN
2115 s->qscale, s->mpeg_f_code[0][0],s->mpeg_f_code[0][1],s->mpeg_f_code[1][0],s->mpeg_f_code[1][1],
2116 s->pict_type == I_TYPE ? "I" : (s->pict_type == P_TYPE ? "P" : (s->pict_type == B_TYPE ? "B" : "S")),
bb198e19 2117 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
a4337a51
MN
2118 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
2119 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
2120 }
2121 }
2122
2123 s->first_slice = 0;
7bc9090a 2124 if(s->qscale == 0){
9b879566 2125 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
db6e7795 2126 return -1;
7bc9090a
MN
2127 }
2128
de6d9b64 2129 /* extra slice info */
612476ef
A
2130 while (get_bits1(&s->gb) != 0) {
2131 skip_bits(&s->gb, 8);
de6d9b64 2132 }
7bc9090a 2133
ce5b7c5e 2134 s->mb_x=0;
7bc9090a 2135
ce5b7c5e
MN
2136 for(;;) {
2137 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
7bc9090a 2138 if (code < 0){
9b879566 2139 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
db6e7795 2140 return -1;
7bc9090a 2141 }
ce5b7c5e
MN
2142 if (code >= 33) {
2143 if (code == 33) {
2144 s->mb_x += 33;
2145 }
2146 /* otherwise, stuffing, nothing to do */
2147 } else {
2148 s->mb_x += code;
2149 break;
2150 }
2151 }
9b8709d1 2152
7bc9090a
MN
2153 s->resync_mb_x= s->mb_x;
2154 s->resync_mb_y= s->mb_y = start_code;
9b8709d1 2155 s->mb_skip_run= 0;
7d1c3fc1 2156 ff_init_block_index(s);
ce5b7c5e 2157
de6d9b64 2158 for(;;) {
a579db0c
IK
2159#ifdef HAVE_XVMC
2160 //one 1 we memcpy blocks in xvmcvideo
2161 if(s->avctx->xvmc_acceleration > 1)
2162 XVMC_init_block(s);//set s->block
2163#endif
2164
eb4b3dd3 2165 s->dsp.clear_blocks(s->block[0]);
7bc9090a 2166
b7ec19d3 2167 ret = mpeg_decode_mb(s, s->block);
332f9ac4 2168 s->chroma_qscale= s->qscale;
7bc9090a 2169
de6d9b64
FB
2170 dprintf("ret=%d\n", ret);
2171 if (ret < 0)
2172 return -1;
8d7ec294 2173
31b1ec5d
MN
2174 if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
2175 const int wrap = field_pic ? 2*s->block_wrap[0] : s->block_wrap[0];
2176 int xy = s->mb_x*2 + 1 + (s->mb_y*2 +1)*wrap;
fad05f52
WH
2177 int motion_for_top_x, motion_for_top_y, motion_back_top_x, motion_back_top_y;
2178 int motion_for_bottom_x, motion_for_bottom_y, motion_back_bottom_x, motion_back_bottom_y;
31b1ec5d
MN
2179 if(field_pic && !s->first_field)
2180 xy += wrap/2;
2181
db6e7795 2182 if (s->mb_intra) {
fad05f52
WH
2183 motion_for_top_x = motion_for_top_y = motion_back_top_x = motion_back_top_y =
2184 motion_for_bottom_x = motion_for_bottom_y = motion_back_bottom_x = motion_back_bottom_y = 0;
8d7ec294 2185 }else if (s->mv_type == MV_TYPE_16X16){
fad05f52
WH
2186 motion_for_top_x = motion_for_bottom_x = s->mv[0][0][0];
2187 motion_for_top_y = motion_for_bottom_y = s->mv[0][0][1];
2188 motion_back_top_x = motion_back_bottom_x = s->mv[1][0][0];
2189 motion_back_top_y = motion_back_bottom_y = s->mv[1][0][1];
8d7ec294 2190 } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
fad05f52
WH
2191 motion_for_top_x = s->mv[0][0][0];
2192 motion_for_top_y = s->mv[0][0][1];
2193 motion_for_bottom_x = s->mv[0][1][0];
2194 motion_for_bottom_y = s->mv[0][1][1];
2195 motion_back_top_x = s->mv[1][0][0];
2196 motion_back_top_y = s->mv[1][0][1];
2197 motion_back_bottom_x = s->mv[1][1][0];
2198 motion_back_bottom_y = s->mv[1][1][1];
8d7ec294
WH
2199 }
2200
fad05f52
WH
2201 s->current_picture.motion_val[0][xy][0] = motion_for_top_x;
2202 s->current_picture.motion_val[0][xy][1] = motion_for_top_y;
2203 s->current_picture.motion_val[0][xy + 1][0] = motion_for_top_x;
2204 s->current_picture.motion_val[0][xy + 1][1] = motion_for_top_y;
2205 s->current_picture.motion_val[0][xy + wrap][0] = motion_for_bottom_x;
2206 s->current_picture.motion_val[0][xy + wrap][1] = motion_for_bottom_y;
2207 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_for_bottom_x;
2208 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_for_bottom_y;
8d7ec294
WH
2209
2210 if(s->pict_type != B_TYPE){
fad05f52 2211 motion_back_top_x = motion_back_top_y = motion_back_bottom_x = motion_back_bottom_y = 0;
7bc9090a 2212 }
8d7ec294 2213
fad05f52
WH
2214 s->current_picture.motion_val[1][xy][0] = motion_back_top_x;
2215 s->current_picture.motion_val[1][xy][1] = motion_back_top_y;
2216 s->current_picture.motion_val[1][xy + 1][0] = motion_back_top_x;
2217 s->current_picture.motion_val[1][xy + 1][1] = motion_back_top_y;
2218 s->current_picture.motion_val[1][xy + wrap][0] = motion_back_bottom_x;
2219 s->current_picture.motion_val[1][xy + wrap][1] = motion_back_bottom_y;
2220 s->current_picture.motion_val[1][xy + 1 + wrap][0] = motion_back_bottom_x;
2221 s->current_picture.motion_val[1][xy + 1 + wrap][1] = motion_back_bottom_y;
7bc9090a 2222 }
8d7ec294 2223
7d1c3fc1
MN
2224 s->dest[0] += 16;
2225 s->dest[1] += 8;
2226 s->dest[2] += 8;
ce5b7c5e 2227
7d1c3fc1
MN
2228 MPV_decode_mb(s, s->block);
2229
ce5b7c5e 2230 if (++s->mb_x >= s->mb_width) {
ff862be5 2231
3bb07d61 2232 ff_draw_horiz_band(s, 16*s->mb_y, 16);
ce5b7c5e
MN
2233
2234 s->mb_x = 0;
2235 s->mb_y++;
cf713bb8
MN
2236
2237 if(s->mb_y<<field_pic >= s->mb_height){
2238 int left= s->gb.size_in_bits - get_bits_count(&s->gb);
2239
2240 if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)))
2241 || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
9b879566 2242 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d\n", left);
cf713bb8
MN
2243 return -1;
2244 }else
2245 goto eos;
2246 }
7d1c3fc1
MN
2247
2248 ff_init_block_index(s);
ce5b7c5e 2249 }
ce5b7c5e
MN
2250
2251 /* skip mb handling */
9b8709d1 2252 if (s->mb_skip_run == -1) {
ce5b7c5e 2253 /* read again increment */
9b8709d1 2254 s->mb_skip_run = 0;
ce5b7c5e
MN
2255 for(;;) {
2256 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
7bc9090a 2257 if (code < 0){
9b879566 2258 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
9c00c3af 2259 return -1;
7bc9090a 2260 }
ce5b7c5e
MN
2261 if (code >= 33) {
2262 if (code == 33) {
9b8709d1 2263 s->mb_skip_run += 33;
9c00c3af
MN
2264 }else if(code == 35){
2265 if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
9b879566 2266 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
9c00c3af
MN
2267 return -1;
2268 }
2269 goto eos; /* end of slice */
ce5b7c5e
MN
2270 }
2271 /* otherwise, stuffing, nothing to do */
2272 } else {
9b8709d1 2273 s->mb_skip_run += code;
ce5b7c5e
MN
2274 break;
2275 }
2276 }
2277 }
de6d9b64 2278 }
db6e7795
MN
2279eos: // end of slice
2280 *buf += get_bits_count(&s->gb)/8 - 1;
7bc9090a 2281//printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
db6e7795
MN
2282 return 0;
2283}
7bc9090a 2284
db6e7795
MN
2285/**
2286 * handles slice ends.
2287 * @return 1 if it seems to be the last slice of
2288 */
2289static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2290{
2291 Mpeg1Context *s1 = avctx->priv_data;
2292 MpegEncContext *s = &s1->mpeg_enc_ctx;
2293
36b58e85 2294 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
855127bc
FB
2295 return 0;
2296
2e7b4c84
IK
2297#ifdef HAVE_XVMC
2298 if(s->avctx->xvmc_acceleration)
2299 XVMC_field_end(s);
2300#endif
de6d9b64 2301 /* end of slice reached */
db6e7795 2302 if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
de6d9b64 2303 /* end of image */
1e491e29 2304
029911d1 2305 if(s->codec_id == CODEC_ID_MPEG2VIDEO){
0426af31
MN
2306 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
2307 }else
2308 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG1;
2309
7bc9090a 2310 ff_er_frame_end(s);
de6d9b64
FB
2311
2312 MPV_frame_end(s);
2313
4e00e76b 2314 if (s->pict_type == B_TYPE || s->low_delay) {
8e937a4a 2315 *pict= *(AVFrame*)s->current_picture_ptr;
0c9bbaec 2316 ff_print_debug_info(s, pict);
de6d9b64 2317 } else {
1e491e29 2318 s->picture_number++;
de6d9b64
FB
2319 /* latency of 1 frame for I and P frames */
2320 /* XXX: use another variable than picture_number */
80097bbf 2321 if (s->last_picture_ptr != NULL) {
8e937a4a 2322 *pict= *(AVFrame*)s->last_picture_ptr;
0c9bbaec 2323 ff_print_debug_info(s, pict);
de6d9b64 2324 }
de6d9b64 2325 }
ff862be5 2326
db6e7795 2327 return 1;
de6d9b64 2328 } else {
db6e7795 2329 return 0;
de6d9b64
FB
2330 }
2331}
2332
2333static int mpeg1_decode_sequence(AVCodecContext *avctx,
0c1a9eda 2334 uint8_t *buf, int buf_size)
de6d9b64
FB
2335{
2336 Mpeg1Context *s1 = avctx->priv_data;
2337 MpegEncContext *s = &s1->mpeg_enc_ctx;
60832448 2338 int width, height, i, v, j;
945f15b7 2339 float aspect;
fb4a4a56 2340
68f593b4 2341 init_get_bits(&s->gb, buf, buf_size*8);
de6d9b64
FB
2342
2343 width = get_bits(&s->gb, 12);
2344 height = get_bits(&s->gb, 12);
945f15b7 2345 s->aspect_ratio_info= get_bits(&s->gb, 4);
32e7b91a
FB
2346 if (s->aspect_ratio_info == 0)
2347 return -1;
2348 aspect= 1.0/mpeg1_aspect[s->aspect_ratio_info];
2349 avctx->sample_aspect_ratio= av_d2q(aspect, 255);
945f15b7 2350
de6d9b64
FB
2351 s->frame_rate_index = get_bits(&s->gb, 4);
2352 if (s->frame_rate_index == 0)
2353 return -1;
2354 s->bit_rate = get_bits(&s->gb, 18) * 400;
612476ef 2355 if (get_bits1(&s->gb) == 0) /* marker */
de6d9b64
FB
2356 return -1;
2357 if (width <= 0 || height <= 0 ||
2358 (width % 2) != 0 || (height % 2) != 0)
2359 return -1;
2360 if (width != s->width ||
2361 height != s->height) {
2362 /* start new mpeg1 context decoding */
2363 s->out_format = FMT_MPEG1;
2364 if (s1->mpeg_enc_ctx_allocated) {
2365 MPV_common_end(s);
2366 }
2367 s->width = width;
2368 s->height = height;
4e00e76b 2369 avctx->has_b_frames= 1;
0c23ead1 2370 s->avctx = avctx;
de6d9b64
FB
2371 avctx->width = width;
2372 avctx->height = height;
14bea432
MN
2373 av_reduce(
2374 &avctx->frame_rate,
2375 &avctx->frame_rate_base,
2376 frame_rate_tab[s->frame_rate_index],
2377 MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form
2378 1<<30
2379 );
de6d9b64
FB
2380 avctx->bit_rate = s->bit_rate;
2381
2e7b4c84
IK
2382 //get_format() or set_video(width,height,aspect,pix_fmt);
2383 //until then pix_fmt may be changed right after codec init
2384 if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
a579db0c
IK
2385 if( avctx->idct_algo == FF_IDCT_AUTO )
2386 avctx->idct_algo = FF_IDCT_SIMPLE;
2e7b4c84 2387
de6d9b64
FB
2388 if (MPV_common_init(s) < 0)
2389 return -1;
de6d9b64 2390 s1->mpeg_enc_ctx_allocated = 1;
a579db0c 2391 s->swap_uv = 0;//just in case vcr2 and mpeg2 stream have been concatinated
de6d9b64
FB
2392 }
2393
612476ef
A
2394 skip_bits(&s->gb, 10); /* vbv_buffer_size */
2395 skip_bits(&s->gb, 1);
de6d9b64
FB
2396
2397 /* get matrix */
612476ef 2398 if (get_bits1(&s->gb)) {
de6d9b64
FB
2399 for(i=0;i<64;i++) {
2400 v = get_bits(&s->gb, 8);
2ad1516a 2401 j = s->intra_scantable.permutated[i];
60832448
FB
2402 s->intra_matrix[j] = v;
2403 s->chroma_intra_matrix[j] = v;
de6d9b64 2404 }
25ed7f92
FB
2405#ifdef DEBUG
2406 dprintf("intra matrix present\n");
2407 for(i=0;i<64;i++)
8e1652dc 2408 dprintf(" %d", s->intra_matrix[s->intra_scantable.permutated[i]]);
25ed7f92
FB
2409 printf("\n");
2410#endif
de6d9b64
FB
2411 } else {
2412 for(i=0;i<64;i++) {
b0368839 2413 int j= s->dsp.idct_permutation[i];
adc09b2e 2414 v = ff_mpeg1_default_intra_matrix[i];
2ad1516a
MN
2415 s->intra_matrix[j] = v;
2416 s->chroma_intra_matrix[j] = v;
de6d9b64
FB
2417 }
2418 }
612476ef 2419 if (get_bits1(&s->gb)) {
de6d9b64
FB
2420 for(i=0;i<64;i++) {
2421 v = get_bits(&s->gb, 8);
2ad1516a 2422 j = s->intra_scantable.permutated[i];
d7e9533a
MN
2423 s->inter_matrix[j] = v;
2424 s->chroma_inter_matrix[j] = v;
de6d9b64 2425 }
25ed7f92
FB
2426#ifdef DEBUG
2427 dprintf("non intra matrix present\n");
2428 for(i=0;i<64;i++)
8e1652dc 2429 dprintf(" %d", s->inter_matrix[s->intra_scantable.permutated[i]]);
25ed7f92
FB
2430 printf("\n");
2431#endif
de6d9b64
FB
2432 } else {
2433 for(i=0;i<64;i++) {
b0368839 2434 int j= s->dsp.idct_permutation[i];
adc09b2e 2435 v = ff_mpeg1_default_non_intra_matrix[i];
2ad1516a
MN
2436 s->inter_matrix[j] = v;
2437 s->chroma_inter_matrix[j] = v;
de6d9b64
FB
2438 }
2439 }
2440
2441 /* we set mpeg2 parameters so that it emulates mpeg1 */
2442 s->progressive_sequence = 1;
2443 s->progressive_frame = 1;
2444 s->picture_structure = PICT_FRAME;
2445 s->frame_pred_frame_dct = 1;
029911d1 2446 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
fb4a4a56 2447 avctx->sub_id = 1; /* indicates mpeg1 */
248a189a 2448 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
de6d9b64
FB
2449 return 0;
2450}
2451
e94bc100
MN
2452static int vcr2_init_sequence(AVCodecContext *avctx)
2453{
2454 Mpeg1Context *s1 = avctx->priv_data;
2455 MpegEncContext *s = &s1->mpeg_enc_ctx;
008f0851 2456 int i, v;
e94bc100
MN
2457
2458 /* start new mpeg1 context decoding */
2459 s->out_format = FMT_MPEG1;
2460 if (s1->mpeg_enc_ctx_allocated) {
2461 MPV_common_end(s);
2462 }
2463 s->width = avctx->width;
2464 s->height = avctx->height;
2465 avctx->has_b_frames= 0; //true?
ff862be5 2466 s->low_delay= 1;
e94bc100 2467 s->avctx = avctx;
2e7b4c84
IK
2468
2469 //get_format() or set_video(width,height,aspect,pix_fmt);
2470 //until then pix_fmt may be changed right after codec init
2471 if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
a579db0c
IK
2472 if( avctx->idct_algo == FF_IDCT_AUTO )
2473 avctx->idct_algo = FF_IDCT_SIMPLE;
e94bc100
MN
2474
2475 if (MPV_common_init(s) < 0)
2476 return -1;
a579db0c
IK
2477 exchange_uv(s);//common init reset pblocks, so we swap them here
2478 s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB
e94bc100
MN
2479 s1->mpeg_enc_ctx_allocated = 1;
2480
2481 for(i=0;i<64;i++) {
2482 int j= s->dsp.idct_permutation[i];
2483 v = ff_mpeg1_default_intra_matrix[i];
2484 s->intra_matrix[j] = v;
2485 s->chroma_intra_matrix[j] = v;
2486
2487 v = ff_mpeg1_default_non_intra_matrix[i];
2488 s->inter_matrix[j] = v;
2489 s->chroma_inter_matrix[j] = v;
2490 }
2491
e94bc100
MN
2492 s->progressive_sequence = 1;
2493 s->progressive_frame = 1;
2494 s->picture_structure = PICT_FRAME;
2495 s->frame_pred_frame_dct = 1;
029911d1 2496 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
008f0851 2497 avctx->sub_id = 2; /* indicates mpeg2 */
e94bc100
MN
2498 return 0;
2499}
2500
2501
e2f9490e
FB
2502static void mpeg_decode_user_data(AVCodecContext *avctx,
2503 const uint8_t *buf, int buf_size)
2504{
2505 const uint8_t *p;
2506 int len, flags;
2507 p = buf;
2508 len = buf_size;
2509
2510 /* we parse the DTG active format information */
2511 if (len >= 5 &&
2512 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2513 flags = p[4];
2514 p += 5;
2515 len -= 5;
2516 if (flags & 0x80) {
2517 /* skip event id */
2518 if (len < 2)
2519 return;
2520 p += 2;
2521 len -= 2;
2522 }
2523 if (flags & 0x40) {
2524 if (len < 1)
2525 return;
2526 avctx->dtg_active_format = p[0] & 0x0f;
2527 }
2528 }
2529}
2530
80097bbf
MN
2531/**
2532 * finds the end of the current frame in the bitstream.
2533 * @return the position of the first byte of the next frame, or -1
2534 */
2535static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){
2536 ParseContext *pc= &s->parse_context;
2537 int i;
2538 uint32_t state;
2539
2540 state= pc->state;
2541
2542 i=0;
2543 if(!pc->frame_start_found){
2544 for(i=0; i<buf_size; i++){
2545 state= (state<<8) | buf[i];
2546 if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2547 i++;
2548 pc->frame_start_found=1;
2549 break;
2550 }
2551 }
2552 }
2553
2554 if(pc->frame_start_found){
2555 for(; i<buf_size; i++){
2556 state= (state<<8) | buf[i];
2557 if((state&0xFFFFFF00) == 0x100){
2558 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2559 pc->frame_start_found=0;
2560 pc->state=-1;
2561 return i-3;
2562 }
2563 }
2564 }
2565 }
2566 pc->state= state;
bb463d81 2567 return END_NOT_FOUND;
80097bbf
MN
2568}
2569
de6d9b64
FB
2570/* handle buffering and image synchronisation */
2571static int mpeg_decode_frame(AVCodecContext *avctx,
2572 void *data, int *data_size,
0c1a9eda 2573 uint8_t *buf, int buf_size)
de6d9b64
FB
2574{
2575 Mpeg1Context *s = avctx->priv_data;
80097bbf
MN
2576 uint8_t *buf_end, *buf_ptr;
2577 int ret, start_code, input_size;
492cd3a9 2578 AVFrame *picture = data;
1cb0edb4 2579 MpegEncContext *s2 = &s->mpeg_enc_ctx;
de6d9b64
FB
2580 dprintf("fill_buffer\n");
2581
2582 *data_size = 0;
d7e9533a 2583
de6d9b64 2584 /* special case for last picture */
e9174ba4
MN
2585 if (buf_size == 0 && s2->low_delay==0 && s2->next_picture_ptr) {
2586 *picture= *(AVFrame*)s2->next_picture_ptr;
2587 s2->next_picture_ptr= NULL;
1e491e29 2588
e9174ba4 2589 *data_size = sizeof(AVFrame);
de6d9b64
FB
2590 return 0;
2591 }
2592
80097bbf 2593 if(s2->flags&CODEC_FLAG_TRUNCATED){
bb463d81 2594 int next= mpeg1_find_frame_end(s2, buf, buf_size);
80097bbf
MN
2595
2596 if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 )
2597 return buf_size;
2598 }
2599
de6d9b64
FB
2600 buf_ptr = buf;
2601 buf_end = buf + buf_size;
e0a3d744
J
2602
2603#if 0
2604 if (s->repeat_field % 2 == 1) {
1cb0edb4
J
2605 s->repeat_field++;
2606 //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
e0a3d744
J
2607 // s2->picture_number, s->repeat_field);
2608 if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2609 *data_size = sizeof(AVPicture);
2610 goto the_end;
2611 }
1cb0edb4 2612 }
e0a3d744 2613#endif
e94bc100
MN
2614
2615 if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2616 vcr2_init_sequence(avctx);
2617
80097bbf 2618 for(;;) {
de6d9b64 2619 /* find start next code */
80097bbf 2620 start_code = find_start_code(&buf_ptr, buf_end);
cfcff636 2621 if (start_code < 0){
80de6a80
MN
2622 if(s2->pict_type != B_TYPE || avctx->hurry_up==0){
2623 if (slice_end(avctx, picture)) {
248a189a 2624 if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
80de6a80
MN
2625 *data_size = sizeof(AVPicture);
2626 }
db6e7795 2627 }
cfcff636 2628 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
de6d9b64 2629 }
cf713bb8
MN
2630
2631 input_size = buf_end - buf_ptr;
2632
2633 if(avctx->debug & FF_DEBUG_STARTCODE){
9b879566 2634 av_log(avctx, AV_LOG_DEBUG, "%3X at %d left %d\n", start_code, buf_ptr-buf, input_size);
cf713bb8 2635 }
80097bbf 2636
de6d9b64 2637 /* prepare data for next start code */
de6d9b64
FB
2638 switch(start_code) {
2639 case SEQ_START_CODE:
80097bbf 2640 mpeg1_decode_sequence(avctx, buf_ptr,
de6d9b64
FB
2641 input_size);
2642 break;
2643
2644 case PICTURE_START_CODE:
2645 /* we have a complete image : we try to decompress it */
2646 mpeg1_decode_picture(avctx,
80097bbf 2647 buf_ptr, input_size);
de6d9b64
FB
2648 break;
2649 case EXT_START_CODE:
2650 mpeg_decode_extension(avctx,
80097bbf 2651 buf_ptr, input_size);
e2f9490e
FB
2652 break;
2653 case USER_START_CODE:
2654 mpeg_decode_user_data(avctx,
80097bbf 2655 buf_ptr, input_size);
de6d9b64 2656 break;
05fd1577
MN
2657 case GOP_START_CODE:
2658 s2->first_field=0;
2659 break;
de6d9b64
FB
2660 default:
2661 if (start_code >= SLICE_MIN_START_CODE &&
d9cb5429 2662 start_code <= SLICE_MAX_START_CODE) {
945f15b7
MN
2663
2664 /* skip b frames if we dont have reference frames */
b536d0aa 2665 if(s2->last_picture_ptr==NULL && s2->pict_type==B_TYPE) break;
945f15b7
MN
2666 /* skip b frames if we are in a hurry */
2667 if(avctx->hurry_up && s2->pict_type==B_TYPE) break;
2668 /* skip everything if we are in a hurry>=5 */
2669 if(avctx->hurry_up>=5) break;
80097bbf 2670
37b787f1
MN
2671 if (!s->mpeg_enc_ctx_allocated) break;
2672
de6d9b64 2673 ret = mpeg_decode_slice(avctx, picture,
80097bbf 2674 start_code, &buf_ptr, input_size);
db6e7795 2675 emms_c();
dfb476cb 2676
db6e7795
MN
2677 if(ret < 0){
2678 if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
7bc9090a 2679 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
db6e7795
MN
2680 if(ret==DECODE_SLICE_FATAL_ERROR) return -1;
2681 }else{
2682 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END);
de6d9b64
FB
2683 }
2684 }
2685 break;
2686 }
de6d9b64 2687 }
de6d9b64
FB
2688}
2689
2690static int mpeg_decode_end(AVCodecContext *avctx)
2691{
2692 Mpeg1Context *s = avctx->priv_data;
2693
2694 if (s->mpeg_enc_ctx_allocated)
2695 MPV_common_end(&s->mpeg_enc_ctx);
2696 return 0;
2697}
2698
922bc38d
MN
2699AVCodec mpeg1video_decoder = {
2700 "mpeg1video",
de6d9b64
FB
2701 CODEC_TYPE_VIDEO,
2702 CODEC_ID_MPEG1VIDEO,
2703 sizeof(Mpeg1Context),
2704 mpeg_decode_init,
2705 NULL,
2706 mpeg_decode_end,
2707 mpeg_decode_frame,
d7425f59 2708 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
922bc38d
MN
2709 .flush= ff_mpeg_flush,
2710};
2711
2712AVCodec mpeg2video_decoder = {
2713 "mpeg2video",
2714 CODEC_TYPE_VIDEO,
2715 CODEC_ID_MPEG2VIDEO,
2716 sizeof(Mpeg1Context),
2717 mpeg_decode_init,
2718 NULL,
2719 mpeg_decode_end,
2720 mpeg_decode_frame,
2721 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
c512b303
IK
2722 .flush= ff_mpeg_flush,
2723};
2724
2725//legacy decoder
2726AVCodec mpegvideo_decoder = {
2727 "mpegvideo",
2728 CODEC_TYPE_VIDEO,
2729 CODEC_ID_MPEG2VIDEO,
2730 sizeof(Mpeg1Context),
2731 mpeg_decode_init,
2732 NULL,
2733 mpeg_decode_end,
2734 mpeg_decode_frame,
2735 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
7a06ff14 2736 .flush= ff_mpeg_flush,
de6d9b64 2737};
2e7b4c84
IK
2738
2739#ifdef HAVE_XVMC
2740static int mpeg_mc_decode_init(AVCodecContext *avctx){
2741 Mpeg1Context *s;
2742
2743 if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2744 return -1;
a579db0c 2745 if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2e7b4c84 2746 dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
a579db0c 2747 }
2e7b4c84
IK
2748 mpeg_decode_init(avctx);
2749 s = avctx->priv_data;
2750
2751 avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
a579db0c 2752 avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
2e7b4c84
IK
2753
2754 return 0;
2755}
2756
2757AVCodec mpeg_xvmc_decoder = {
2758 "mpegvideo_xvmc",
2759 CODEC_TYPE_VIDEO,
2760 CODEC_ID_MPEG2VIDEO_XVMC,
2761 sizeof(Mpeg1Context),
2762 mpeg_mc_decode_init,
2763 NULL,
2764 mpeg_decode_end,
2765 mpeg_decode_frame,
2766 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED,
2767};
2768
2769#endif
c3bf0288
MN
2770
2771/* this is ugly i know, but the alternative is too make
2772 hundreds of vars global and prefix them with ff_mpeg1_
2773 which is far uglier. */
2774#include "mdec.c"