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