Main Page
Related Pages
Modules
Data Structures
Files
Examples
File List
Globals
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 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
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
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
->
err_recognition
&
AV_EF_BITSTREAM
)
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
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
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
.
f
.
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_left
(&s->
gb
) <= 7)
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
.
f
.
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
.
f
.
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
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
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
.
f
.
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 AV_PICTURE_TYPE_I 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
=
AV_PICTURE_TYPE_P
;
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
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
->
f
.
data
[0]) {
574
int
i=
ff_find_unused_picture
(s, 0);
575
if
(i < 0)
576
return
i;
577
s->
current_picture_ptr
= &s->
picture
[i];
578
}
579
580
ret =
h261_decode_picture_header
(h);
581
582
/* skip if the header was thrashed */
583
if
(ret < 0){
584
av_log
(s->
avctx
,
AV_LOG_ERROR
,
"header damaged\n"
);
585
return
-1;
586
}
587
588
if
(s->
width
!= avctx->
coded_width
|| s->
height
!= avctx->
coded_height
){
589
ParseContext
pc= s->
parse_context
;
//FIXME move this demuxing hack to libavformat
590
s->
parse_context
.
buffer
=0;
591
MPV_common_end
(s);
592
s->
parse_context
= pc;
593
}
594
if
(!s->
context_initialized
) {
595
avcodec_set_dimensions
(avctx, s->
width
, s->
height
);
596
597
goto
retry;
598
}
599
600
// for skipping the frame
601
s->
current_picture
.
f
.
pict_type
= s->
pict_type
;
602
s->
current_picture
.
f
.
key_frame
= s->
pict_type
==
AV_PICTURE_TYPE_I
;
603
604
if
( (avctx->
skip_frame
>=
AVDISCARD_NONREF
&& s->
pict_type
==
AV_PICTURE_TYPE_B
)
605
||(avctx->
skip_frame
>=
AVDISCARD_NONKEY
&& s->
pict_type
!=
AV_PICTURE_TYPE_I
)
606
|| avctx->
skip_frame
>=
AVDISCARD_ALL
)
607
return
get_consumed_bytes
(s, buf_size);
608
609
if
(
MPV_frame_start
(s, avctx) < 0)
610
return
-1;
611
612
ff_er_frame_start
(s);
613
614
/* decode each macroblock */
615
s->
mb_x
=0;
616
s->
mb_y
=0;
617
618
while
(h->
gob_number
< (s->
mb_height
==18 ? 12 : 5)){
619
if
(
ff_h261_resync
(h)<0)
620
break
;
621
h261_decode_gob
(h);
622
}
623
MPV_frame_end
(s);
624
625
assert(s->
current_picture
.
f
.
pict_type
== s->
current_picture_ptr
->
f
.
pict_type
);
626
assert(s->
current_picture
.
f
.
pict_type
== s->
pict_type
);
627
*pict= *(
AVFrame
*)s->
current_picture_ptr
;
628
ff_print_debug_info
(s, pict);
629
630
*data_size =
sizeof
(
AVFrame
);
631
632
return
get_consumed_bytes
(s, buf_size);
633
}
634
635
static
av_cold
int
h261_decode_end
(
AVCodecContext
*avctx)
636
{
637
H261Context
*h= avctx->
priv_data
;
638
MpegEncContext
*s = &h->
s
;
639
640
MPV_common_end
(s);
641
return
0;
642
}
643
644
AVCodec
ff_h261_decoder
= {
645
.
name
=
"h261"
,
646
.type =
AVMEDIA_TYPE_VIDEO
,
647
.id =
CODEC_ID_H261
,
648
.priv_data_size =
sizeof
(
H261Context
),
649
.
init
=
h261_decode_init
,
650
.
close
=
h261_decode_end
,
651
.
decode
=
h261_decode_frame
,
652
.capabilities =
CODEC_CAP_DR1
,
653
.max_lowres = 3,
654
.long_name =
NULL_IF_CONFIG_SMALL
(
"H.261"
),
655
};