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