ffmpeg / libavcodec / h261dec.c @ 8ed2ae09
History | View | Annotate | Download (18.3 KB)
1 |
/*
|
---|---|
2 |
* H261 decoder
|
3 |
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
|
4 |
* Copyright (c) 2004 Maarten Daniels
|
5 |
*
|
6 |
* This file is part of Libav.
|
7 |
*
|
8 |
* Libav is free software; you can redistribute it and/or
|
9 |
* modify it under the terms of the GNU Lesser General Public
|
10 |
* License as published by the Free Software Foundation; either
|
11 |
* version 2.1 of the License, or (at your option) any later version.
|
12 |
*
|
13 |
* Libav is distributed in the hope that it will be useful,
|
14 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
16 |
* Lesser General Public License for more details.
|
17 |
*
|
18 |
* You should have received a copy of the GNU Lesser General Public
|
19 |
* License along with Libav; if not, write to the Free Software
|
20 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
21 |
*/
|
22 |
|
23 |
/**
|
24 |
* @file
|
25 |
* H.261 decoder.
|
26 |
*/
|
27 |
|
28 |
#include "dsputil.h" |
29 |
#include "avcodec.h" |
30 |
#include "mpegvideo.h" |
31 |
#include "h263.h" |
32 |
#include "h261.h" |
33 |
#include "h261data.h" |
34 |
|
35 |
#define H261_MBA_VLC_BITS 9 |
36 |
#define H261_MTYPE_VLC_BITS 6 |
37 |
#define H261_MV_VLC_BITS 7 |
38 |
#define H261_CBP_VLC_BITS 9 |
39 |
#define TCOEFF_VLC_BITS 9 |
40 |
#define MBA_STUFFING 33 |
41 |
#define MBA_STARTCODE 34 |
42 |
|
43 |
extern uint8_t ff_h261_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3]; |
44 |
|
45 |
static VLC h261_mba_vlc;
|
46 |
static VLC h261_mtype_vlc;
|
47 |
static VLC h261_mv_vlc;
|
48 |
static VLC h261_cbp_vlc;
|
49 |
|
50 |
static int h261_decode_block(H261Context * h, DCTELEM * block, int n, int coded); |
51 |
|
52 |
static av_cold void h261_decode_init_vlc(H261Context *h){ |
53 |
static int done = 0; |
54 |
|
55 |
if(!done){
|
56 |
done = 1;
|
57 |
INIT_VLC_STATIC(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
|
58 |
h261_mba_bits, 1, 1, |
59 |
h261_mba_code, 1, 1, 662); |
60 |
INIT_VLC_STATIC(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
|
61 |
h261_mtype_bits, 1, 1, |
62 |
h261_mtype_code, 1, 1, 80); |
63 |
INIT_VLC_STATIC(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
|
64 |
&h261_mv_tab[0][1], 2, 1, |
65 |
&h261_mv_tab[0][0], 2, 1, 144); |
66 |
INIT_VLC_STATIC(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
|
67 |
&h261_cbp_tab[0][1], 2, 1, |
68 |
&h261_cbp_tab[0][0], 2, 1, 512); |
69 |
init_rl(&h261_rl_tcoeff, ff_h261_rl_table_store); |
70 |
INIT_VLC_RL(h261_rl_tcoeff, 552);
|
71 |
} |
72 |
} |
73 |
|
74 |
static av_cold int h261_decode_init(AVCodecContext *avctx){ |
75 |
H261Context *h= avctx->priv_data; |
76 |
MpegEncContext * const s = &h->s;
|
77 |
|
78 |
// set defaults
|
79 |
MPV_decode_defaults(s); |
80 |
s->avctx = avctx; |
81 |
|
82 |
s->width = s->avctx->coded_width; |
83 |
s->height = s->avctx->coded_height; |
84 |
s->codec_id = s->avctx->codec->id; |
85 |
|
86 |
s->out_format = FMT_H261; |
87 |
s->low_delay= 1;
|
88 |
avctx->pix_fmt= PIX_FMT_YUV420P; |
89 |
|
90 |
s->codec_id= avctx->codec->id; |
91 |
|
92 |
h261_decode_init_vlc(h); |
93 |
|
94 |
h->gob_start_code_skipped = 0;
|
95 |
|
96 |
return 0; |
97 |
} |
98 |
|
99 |
/**
|
100 |
* decodes the group of blocks header or slice header.
|
101 |
* @return <0 if an error occurred
|
102 |
*/
|
103 |
static int h261_decode_gob_header(H261Context *h){ |
104 |
unsigned int val; |
105 |
MpegEncContext * const s = &h->s;
|
106 |
|
107 |
if ( !h->gob_start_code_skipped ){
|
108 |
/* Check for GOB Start Code */
|
109 |
val = show_bits(&s->gb, 15);
|
110 |
if(val)
|
111 |
return -1; |
112 |
|
113 |
/* We have a GBSC */
|
114 |
skip_bits(&s->gb, 16);
|
115 |
} |
116 |
|
117 |
h->gob_start_code_skipped = 0;
|
118 |
|
119 |
h->gob_number = get_bits(&s->gb, 4); /* GN */ |
120 |
s->qscale = get_bits(&s->gb, 5); /* GQUANT */ |
121 |
|
122 |
/* Check if gob_number is valid */
|
123 |
if (s->mb_height==18){ //cif |
124 |
if ((h->gob_number<=0) || (h->gob_number>12)) |
125 |
return -1; |
126 |
} |
127 |
else{ //qcif |
128 |
if ((h->gob_number!=1) && (h->gob_number!=3) && (h->gob_number!=5)) |
129 |
return -1; |
130 |
} |
131 |
|
132 |
/* GEI */
|
133 |
while (get_bits1(&s->gb) != 0) { |
134 |
skip_bits(&s->gb, 8);
|
135 |
} |
136 |
|
137 |
if(s->qscale==0) { |
138 |
av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
|
139 |
if (s->avctx->error_recognition >= FF_ER_COMPLIANT)
|
140 |
return -1; |
141 |
} |
142 |
|
143 |
// For the first transmitted macroblock in a GOB, MBA is the absolute address. For
|
144 |
// subsequent macroblocks, MBA is the difference between the absolute addresses of
|
145 |
// the macroblock and the last transmitted macroblock.
|
146 |
h->current_mba = 0;
|
147 |
h->mba_diff = 0;
|
148 |
|
149 |
return 0; |
150 |
} |
151 |
|
152 |
/**
|
153 |
* decodes the group of blocks / video packet header.
|
154 |
* @return <0 if no resync found
|
155 |
*/
|
156 |
static int ff_h261_resync(H261Context *h){ |
157 |
MpegEncContext * const s = &h->s;
|
158 |
int left, ret;
|
159 |
|
160 |
if ( h->gob_start_code_skipped ){
|
161 |
ret= h261_decode_gob_header(h); |
162 |
if(ret>=0) |
163 |
return 0; |
164 |
} |
165 |
else{
|
166 |
if(show_bits(&s->gb, 15)==0){ |
167 |
ret= h261_decode_gob_header(h); |
168 |
if(ret>=0) |
169 |
return 0; |
170 |
} |
171 |
//OK, it is not where it is supposed to be ...
|
172 |
s->gb= s->last_resync_gb; |
173 |
align_get_bits(&s->gb); |
174 |
left= get_bits_left(&s->gb); |
175 |
|
176 |
for(;left>15+1+4+5; left-=8){ |
177 |
if(show_bits(&s->gb, 15)==0){ |
178 |
GetBitContext bak= s->gb; |
179 |
|
180 |
ret= h261_decode_gob_header(h); |
181 |
if(ret>=0) |
182 |
return 0; |
183 |
|
184 |
s->gb= bak; |
185 |
} |
186 |
skip_bits(&s->gb, 8);
|
187 |
} |
188 |
} |
189 |
|
190 |
return -1; |
191 |
} |
192 |
|
193 |
/**
|
194 |
* decodes skipped macroblocks
|
195 |
* @return 0
|
196 |
*/
|
197 |
static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 ) |
198 |
{ |
199 |
MpegEncContext * const s = &h->s;
|
200 |
int i;
|
201 |
|
202 |
s->mb_intra = 0;
|
203 |
|
204 |
for(i=mba1; i<mba2; i++){
|
205 |
int j, xy;
|
206 |
|
207 |
s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11; |
208 |
s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11; |
209 |
xy = s->mb_x + s->mb_y * s->mb_stride; |
210 |
ff_init_block_index(s); |
211 |
ff_update_block_index(s); |
212 |
|
213 |
for(j=0;j<6;j++) |
214 |
s->block_last_index[j] = -1;
|
215 |
|
216 |
s->mv_dir = MV_DIR_FORWARD; |
217 |
s->mv_type = MV_TYPE_16X16; |
218 |
s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
219 |
s->mv[0][0][0] = 0; |
220 |
s->mv[0][0][1] = 0; |
221 |
s->mb_skipped = 1;
|
222 |
h->mtype &= ~MB_TYPE_H261_FIL; |
223 |
|
224 |
MPV_decode_mb(s, s->block); |
225 |
} |
226 |
|
227 |
return 0; |
228 |
} |
229 |
|
230 |
static int decode_mv_component(GetBitContext *gb, int v){ |
231 |
int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2); |
232 |
|
233 |
/* check if mv_diff is valid */
|
234 |
if ( mv_diff < 0 ) |
235 |
return v;
|
236 |
|
237 |
mv_diff = mvmap[mv_diff]; |
238 |
|
239 |
if(mv_diff && !get_bits1(gb))
|
240 |
mv_diff= -mv_diff; |
241 |
|
242 |
v += mv_diff; |
243 |
if (v <=-16) v+= 32; |
244 |
else if(v >= 16) v-= 32; |
245 |
|
246 |
return v;
|
247 |
} |
248 |
|
249 |
static int h261_decode_mb(H261Context *h){ |
250 |
MpegEncContext * const s = &h->s;
|
251 |
int i, cbp, xy;
|
252 |
|
253 |
cbp = 63;
|
254 |
// Read mba
|
255 |
do{
|
256 |
h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
|
257 |
|
258 |
/* Check for slice end */
|
259 |
/* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
|
260 |
if (h->mba_diff == MBA_STARTCODE){ // start code |
261 |
h->gob_start_code_skipped = 1;
|
262 |
return SLICE_END;
|
263 |
} |
264 |
} |
265 |
while( h->mba_diff == MBA_STUFFING ); // stuffing |
266 |
|
267 |
if ( h->mba_diff < 0 ){ |
268 |
if ( get_bits_count(&s->gb) + 7 >= s->gb.size_in_bits ) |
269 |
return SLICE_END;
|
270 |
|
271 |
av_log(s->avctx, AV_LOG_ERROR, "illegal mba at %d %d\n", s->mb_x, s->mb_y);
|
272 |
return SLICE_ERROR;
|
273 |
} |
274 |
|
275 |
h->mba_diff += 1;
|
276 |
h->current_mba += h->mba_diff; |
277 |
|
278 |
if ( h->current_mba > MBA_STUFFING )
|
279 |
return SLICE_ERROR;
|
280 |
|
281 |
s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11); |
282 |
s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11); |
283 |
xy = s->mb_x + s->mb_y * s->mb_stride; |
284 |
ff_init_block_index(s); |
285 |
ff_update_block_index(s); |
286 |
|
287 |
// Read mtype
|
288 |
h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
|
289 |
h->mtype = h261_mtype_map[h->mtype]; |
290 |
|
291 |
// Read mquant
|
292 |
if ( IS_QUANT ( h->mtype ) ){
|
293 |
ff_set_qscale(s, get_bits(&s->gb, 5));
|
294 |
} |
295 |
|
296 |
s->mb_intra = IS_INTRA4x4(h->mtype); |
297 |
|
298 |
// Read mv
|
299 |
if ( IS_16X16 ( h->mtype ) ){
|
300 |
// Motion vector data is included for all MC macroblocks. MVD is obtained from the macroblock vector by subtracting the
|
301 |
// vector of the preceding macroblock. For this calculation the vector of the preceding macroblock is regarded as zero in the
|
302 |
// following three situations:
|
303 |
// 1) evaluating MVD for macroblocks 1, 12 and 23;
|
304 |
// 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
|
305 |
// 3) MTYPE of the previous macroblock was not MC.
|
306 |
if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) || |
307 |
( h->mba_diff != 1))
|
308 |
{ |
309 |
h->current_mv_x = 0;
|
310 |
h->current_mv_y = 0;
|
311 |
} |
312 |
|
313 |
h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x); |
314 |
h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y); |
315 |
}else{
|
316 |
h->current_mv_x = 0;
|
317 |
h->current_mv_y = 0;
|
318 |
} |
319 |
|
320 |
// Read cbp
|
321 |
if ( HAS_CBP( h->mtype ) ){
|
322 |
cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1; |
323 |
} |
324 |
|
325 |
if(s->mb_intra){
|
326 |
s->current_picture.mb_type[xy]= MB_TYPE_INTRA; |
327 |
goto intra;
|
328 |
} |
329 |
|
330 |
//set motion vectors
|
331 |
s->mv_dir = MV_DIR_FORWARD; |
332 |
s->mv_type = MV_TYPE_16X16; |
333 |
s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; |
334 |
s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation |
335 |
s->mv[0][0][1] = h->current_mv_y * 2; |
336 |
|
337 |
intra:
|
338 |
/* decode each block */
|
339 |
if(s->mb_intra || HAS_CBP(h->mtype)){
|
340 |
s->dsp.clear_blocks(s->block[0]);
|
341 |
for (i = 0; i < 6; i++) { |
342 |
if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){ |
343 |
return SLICE_ERROR;
|
344 |
} |
345 |
cbp+=cbp; |
346 |
} |
347 |
}else{
|
348 |
for (i = 0; i < 6; i++) |
349 |
s->block_last_index[i]= -1;
|
350 |
} |
351 |
|
352 |
MPV_decode_mb(s, s->block); |
353 |
|
354 |
return SLICE_OK;
|
355 |
} |
356 |
|
357 |
/**
|
358 |
* decodes a macroblock
|
359 |
* @return <0 if an error occurred
|
360 |
*/
|
361 |
static int h261_decode_block(H261Context * h, DCTELEM * block, |
362 |
int n, int coded) |
363 |
{ |
364 |
MpegEncContext * const s = &h->s;
|
365 |
int code, level, i, j, run;
|
366 |
RLTable *rl = &h261_rl_tcoeff; |
367 |
const uint8_t *scan_table;
|
368 |
|
369 |
// For the variable length encoding there are two code tables, one being used for
|
370 |
// the first transmitted LEVEL in INTER, INTER+MC and INTER+MC+FIL blocks, the second
|
371 |
// for all other LEVELs except the first one in INTRA blocks which is fixed length
|
372 |
// coded with 8 bits.
|
373 |
// NOTE: the two code tables only differ in one VLC so we handle that manually.
|
374 |
scan_table = s->intra_scantable.permutated; |
375 |
if (s->mb_intra){
|
376 |
/* DC coef */
|
377 |
level = get_bits(&s->gb, 8);
|
378 |
// 0 (00000000b) and -128 (10000000b) are FORBIDDEN
|
379 |
if((level&0x7F) == 0){ |
380 |
av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
|
381 |
return -1; |
382 |
} |
383 |
// The code 1000 0000 is not used, the reconstruction level of 1024 being coded as 1111 1111.
|
384 |
if (level == 255) |
385 |
level = 128;
|
386 |
block[0] = level;
|
387 |
i = 1;
|
388 |
}else if(coded){ |
389 |
// Run Level Code
|
390 |
// EOB Not possible for first level when cbp is available (that's why the table is different)
|
391 |
// 0 1 1s
|
392 |
// * * 0*
|
393 |
int check = show_bits(&s->gb, 2); |
394 |
i = 0;
|
395 |
if ( check & 0x2 ){ |
396 |
skip_bits(&s->gb, 2);
|
397 |
block[0] = ( check & 0x1 ) ? -1 : 1; |
398 |
i = 1;
|
399 |
} |
400 |
}else{
|
401 |
i = 0;
|
402 |
} |
403 |
if(!coded){
|
404 |
s->block_last_index[n] = i - 1;
|
405 |
return 0; |
406 |
} |
407 |
for(;;){
|
408 |
code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
|
409 |
if (code < 0){ |
410 |
av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
|
411 |
return -1; |
412 |
} |
413 |
if (code == rl->n) {
|
414 |
/* escape */
|
415 |
// The remaining combinations of (run, level) are encoded with a 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits level.
|
416 |
run = get_bits(&s->gb, 6);
|
417 |
level = get_sbits(&s->gb, 8);
|
418 |
}else if(code == 0){ |
419 |
break;
|
420 |
}else{
|
421 |
run = rl->table_run[code]; |
422 |
level = rl->table_level[code]; |
423 |
if (get_bits1(&s->gb))
|
424 |
level = -level; |
425 |
} |
426 |
i += run; |
427 |
if (i >= 64){ |
428 |
av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
|
429 |
return -1; |
430 |
} |
431 |
j = scan_table[i]; |
432 |
block[j] = level; |
433 |
i++; |
434 |
} |
435 |
s->block_last_index[n] = i-1;
|
436 |
return 0; |
437 |
} |
438 |
|
439 |
/**
|
440 |
* decodes the H261 picture header.
|
441 |
* @return <0 if no startcode found
|
442 |
*/
|
443 |
static int h261_decode_picture_header(H261Context *h){ |
444 |
MpegEncContext * const s = &h->s;
|
445 |
int format, i;
|
446 |
uint32_t startcode= 0;
|
447 |
|
448 |
for(i= get_bits_left(&s->gb); i>24; i-=1){ |
449 |
startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF; |
450 |
|
451 |
if(startcode == 0x10) |
452 |
break;
|
453 |
} |
454 |
|
455 |
if (startcode != 0x10){ |
456 |
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
|
457 |
return -1; |
458 |
} |
459 |
|
460 |
/* temporal reference */
|
461 |
i= get_bits(&s->gb, 5); /* picture timestamp */ |
462 |
if(i < (s->picture_number&31)) |
463 |
i += 32;
|
464 |
s->picture_number = (s->picture_number&~31) + i;
|
465 |
|
466 |
s->avctx->time_base= (AVRational){1001, 30000}; |
467 |
s->current_picture.pts= s->picture_number; |
468 |
|
469 |
|
470 |
/* PTYPE starts here */
|
471 |
skip_bits1(&s->gb); /* split screen off */
|
472 |
skip_bits1(&s->gb); /* camera off */
|
473 |
skip_bits1(&s->gb); /* freeze picture release off */
|
474 |
|
475 |
format = get_bits1(&s->gb); |
476 |
|
477 |
//only 2 formats possible
|
478 |
if (format == 0){//QCIF |
479 |
s->width = 176;
|
480 |
s->height = 144;
|
481 |
s->mb_width = 11;
|
482 |
s->mb_height = 9;
|
483 |
}else{//CIF |
484 |
s->width = 352;
|
485 |
s->height = 288;
|
486 |
s->mb_width = 22;
|
487 |
s->mb_height = 18;
|
488 |
} |
489 |
|
490 |
s->mb_num = s->mb_width * s->mb_height; |
491 |
|
492 |
skip_bits1(&s->gb); /* still image mode off */
|
493 |
skip_bits1(&s->gb); /* Reserved */
|
494 |
|
495 |
/* PEI */
|
496 |
while (get_bits1(&s->gb) != 0){ |
497 |
skip_bits(&s->gb, 8);
|
498 |
} |
499 |
|
500 |
// h261 has no I-FRAMES, but if we pass FF_I_TYPE for the first frame, the codec crashes if it does
|
501 |
// not contain all I-blocks (e.g. when a packet is lost)
|
502 |
s->pict_type = FF_P_TYPE; |
503 |
|
504 |
h->gob_number = 0;
|
505 |
return 0; |
506 |
} |
507 |
|
508 |
static int h261_decode_gob(H261Context *h){ |
509 |
MpegEncContext * const s = &h->s;
|
510 |
|
511 |
ff_set_qscale(s, s->qscale); |
512 |
|
513 |
/* decode mb's */
|
514 |
while(h->current_mba <= MBA_STUFFING)
|
515 |
{ |
516 |
int ret;
|
517 |
/* DCT & quantize */
|
518 |
ret= h261_decode_mb(h); |
519 |
if(ret<0){ |
520 |
if(ret==SLICE_END){
|
521 |
h261_decode_mb_skipped(h, h->current_mba, 33);
|
522 |
return 0; |
523 |
} |
524 |
av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
|
525 |
return -1; |
526 |
} |
527 |
|
528 |
h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1);
|
529 |
} |
530 |
|
531 |
return -1; |
532 |
} |
533 |
|
534 |
/**
|
535 |
* returns the number of bytes consumed for building the current frame
|
536 |
*/
|
537 |
static int get_consumed_bytes(MpegEncContext *s, int buf_size){ |
538 |
int pos= get_bits_count(&s->gb)>>3; |
539 |
if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...) |
540 |
if(pos+10>buf_size) pos=buf_size; // oops ;) |
541 |
|
542 |
return pos;
|
543 |
} |
544 |
|
545 |
static int h261_decode_frame(AVCodecContext *avctx, |
546 |
void *data, int *data_size, |
547 |
AVPacket *avpkt) |
548 |
{ |
549 |
const uint8_t *buf = avpkt->data;
|
550 |
int buf_size = avpkt->size;
|
551 |
H261Context *h= avctx->priv_data; |
552 |
MpegEncContext *s = &h->s; |
553 |
int ret;
|
554 |
AVFrame *pict = data; |
555 |
|
556 |
av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
|
557 |
av_dlog(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]); |
558 |
s->flags= avctx->flags; |
559 |
s->flags2= avctx->flags2; |
560 |
|
561 |
h->gob_start_code_skipped=0;
|
562 |
|
563 |
retry:
|
564 |
|
565 |
init_get_bits(&s->gb, buf, buf_size*8);
|
566 |
|
567 |
if(!s->context_initialized){
|
568 |
if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix |
569 |
return -1; |
570 |
} |
571 |
|
572 |
//we need to set current_picture_ptr before reading the header, otherwise we cannot store anyting im there
|
573 |
if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){ |
574 |
int i= ff_find_unused_picture(s, 0); |
575 |
s->current_picture_ptr= &s->picture[i]; |
576 |
} |
577 |
|
578 |
ret = h261_decode_picture_header(h); |
579 |
|
580 |
/* skip if the header was thrashed */
|
581 |
if (ret < 0){ |
582 |
av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
|
583 |
return -1; |
584 |
} |
585 |
|
586 |
if (s->width != avctx->coded_width || s->height != avctx->coded_height){
|
587 |
ParseContext pc= s->parse_context; //FIXME move this demuxing hack to libavformat
|
588 |
s->parse_context.buffer=0;
|
589 |
MPV_common_end(s); |
590 |
s->parse_context= pc; |
591 |
} |
592 |
if (!s->context_initialized) {
|
593 |
avcodec_set_dimensions(avctx, s->width, s->height); |
594 |
|
595 |
goto retry;
|
596 |
} |
597 |
|
598 |
// for skipping the frame
|
599 |
s->current_picture.pict_type= s->pict_type; |
600 |
s->current_picture.key_frame= s->pict_type == FF_I_TYPE; |
601 |
|
602 |
#if FF_API_HURRY_UP
|
603 |
/* skip everything if we are in a hurry>=5 */
|
604 |
if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size); |
605 |
#endif
|
606 |
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
|
607 |
||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE) |
608 |
|| avctx->skip_frame >= AVDISCARD_ALL) |
609 |
return get_consumed_bytes(s, buf_size);
|
610 |
|
611 |
if(MPV_frame_start(s, avctx) < 0) |
612 |
return -1; |
613 |
|
614 |
ff_er_frame_start(s); |
615 |
|
616 |
/* decode each macroblock */
|
617 |
s->mb_x=0;
|
618 |
s->mb_y=0;
|
619 |
|
620 |
while(h->gob_number < (s->mb_height==18 ? 12 : 5)){ |
621 |
if(ff_h261_resync(h)<0) |
622 |
break;
|
623 |
h261_decode_gob(h); |
624 |
} |
625 |
MPV_frame_end(s); |
626 |
|
627 |
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type); |
628 |
assert(s->current_picture.pict_type == s->pict_type); |
629 |
*pict= *(AVFrame*)s->current_picture_ptr; |
630 |
ff_print_debug_info(s, pict); |
631 |
|
632 |
*data_size = sizeof(AVFrame);
|
633 |
|
634 |
return get_consumed_bytes(s, buf_size);
|
635 |
} |
636 |
|
637 |
static av_cold int h261_decode_end(AVCodecContext *avctx) |
638 |
{ |
639 |
H261Context *h= avctx->priv_data; |
640 |
MpegEncContext *s = &h->s; |
641 |
|
642 |
MPV_common_end(s); |
643 |
return 0; |
644 |
} |
645 |
|
646 |
AVCodec ff_h261_decoder = { |
647 |
"h261",
|
648 |
AVMEDIA_TYPE_VIDEO, |
649 |
CODEC_ID_H261, |
650 |
sizeof(H261Context),
|
651 |
h261_decode_init, |
652 |
NULL,
|
653 |
h261_decode_end, |
654 |
h261_decode_frame, |
655 |
CODEC_CAP_DR1, |
656 |
.max_lowres = 3,
|
657 |
.long_name = NULL_IF_CONFIG_SMALL("H.261"),
|
658 |
}; |