FFmpeg: libavcodec/ituh263enc.c Source File

FFmpeg

[フレーム]

libavcodec

ituh263enc.c

Go to the documentation of this file.

1 /*

2 * ITU H.263 bitstream encoder

4 * H.263+ support.

7 *

8 * This file is part of FFmpeg.

9 *

10 * FFmpeg is free software; you can redistribute it and/or

11 * modify it under the terms of the GNU Lesser General Public

12 * License as published by the Free Software Foundation; either

13 * version 2.1 of the License, or (at your option) any later version.

14 *

15 * FFmpeg is distributed in the hope that it will be useful,

16 * but WITHOUT ANY WARRANTY; without even the implied warranty of

17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

18 * Lesser General Public License for more details.

19 *

20 * You should have received a copy of the GNU Lesser General Public

21 * License along with FFmpeg; if not, write to the Free Software

22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

23 */

25 /**

26 * @file

27 * H.263 bitstream encoder.

28 */

30 #include "config_components.h"

32 #include <limits.h>

34 #include "libavutil/attributes.h"

35 #include "libavutil/thread.h"

36 #include "avcodec.h"

37 #include "codec_internal.h"

38 #include "mpegvideo.h"

39 #include "mpegvideodata.h"

40 #include "flvenc.h"

41 #include "mpegvideoenc.h"

42 #include "h263.h"

43 #include "h263enc.h"

44 #include "h263data.h"

45 #include "mathops.h"

46 #include "mpegutils.h"

47 #include "internal.h"

49 /**

50 * Table of number of bits a motion vector component needs.

51 */

52 static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];

54 /**

55 * Minimal fcode that a motion vector component would need.

56 */

57 static uint8_t fcode_tab[MAX_MV*2+1];

59 /**

60 * Minimal fcode that a motion vector component would need in umv.

61 * All entries in this table are 1.

62 */

63 static uint8_t umv_fcode_tab[MAX_MV*2+1];

65 //unified encoding tables for run length encoding of coefficients

66 //unified in the sense that the specification specifies the encoding in several steps.

67 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];

68 static uint8_t uni_h263_inter_rl_len [64*64*2*2];

69 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))

70 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)

71 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))

73 static const uint8_t wrong_run[102] = {

74 1, 2, 3, 5, 4, 10, 9, 8,

75 11, 15, 17, 16, 23, 22, 21, 20,

76 19, 18, 25, 24, 27, 26, 11, 7,

77 6, 1, 2, 13, 2, 2, 2, 2,

78 6, 12, 3, 9, 1, 3, 4, 3,

79 7, 4, 1, 1, 5, 5, 14, 6,

80 1, 7, 1, 8, 1, 1, 1, 1,

81 10, 1, 1, 5, 9, 17, 25, 24,

82 29, 33, 32, 41, 2, 23, 28, 31,

83 3, 22, 30, 4, 27, 40, 8, 26,

84 6, 39, 7, 38, 16, 37, 15, 10,

85 11, 12, 13, 14, 1, 21, 20, 18,

86 19, 2, 1, 34, 35, 36

87 };

89 /**

90 * Return the 4 bit value that specifies the given aspect ratio.

91 * This may be one of the standard aspect ratios or it specifies

92 * that the aspect will be stored explicitly later.

93 */

94 av_const int ff_h263_aspect_to_info(AVRational aspect){

95 int i;

97 if(aspect.num==0 || aspect.den==0) aspect= (AVRational){1,1};

99 for(i=1; i<6; i++){

100 if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){

101 return i;

102 }

103 }

104

105 return FF_ASPECT_EXTENDED;

106 }

107

108 void ff_h263_encode_picture_header(MpegEncContext * s)

109 {

110 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;

111 int best_clock_code=1;

112 int best_divisor=60;

113 int best_error= INT_MAX;

114 int custom_pcf;

115

116 if(s->h263_plus){

117 for(i=0; i<2; i++){

118 int div, error;

119 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);

120 div= av_clip(div, 1, 127);

121 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);

122 if(error < best_error){

123 best_error= error;

124 best_divisor= div;

125 best_clock_code= i;

126 }

127 }

128 }

129 custom_pcf = best_clock_code != 1 || best_divisor != 60;

130 coded_frame_rate= 1800000;

131 coded_frame_rate_base= (1000+best_clock_code)*best_divisor;

132

133 align_put_bits(&s->pb);

134

135 /* Update the pointer to last GOB */

136 s->ptr_lastgob = put_bits_ptr(&s->pb);

137 put_bits(&s->pb, 22, 0x20); /* PSC */

138 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp

139 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);

140 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */

141

142 put_bits(&s->pb, 1, 1); /* marker */

143 put_bits(&s->pb, 1, 0); /* H.263 id */

144 put_bits(&s->pb, 1, 0); /* split screen off */

145 put_bits(&s->pb, 1, 0); /* camera off */

146 put_bits(&s->pb, 1, 0); /* freeze picture release off */

147

148 format = ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format), s->width, s->height);

149 if (!s->h263_plus) {

150 /* H.263v1 */

151 put_bits(&s->pb, 3, format);

152 put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));

153 /* By now UMV IS DISABLED ON H.263v1, since the restrictions

154 of H.263v1 UMV implies to check the predicted MV after

155 calculation of the current MB to see if we're on the limits */

156 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */

157 put_bits(&s->pb, 1, 0); /* SAC: off */

158 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */

159 put_bits(&s->pb, 1, 0); /* only I/P-frames, no PB-frame */

160 put_bits(&s->pb, 5, s->qscale);

161 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */

162 } else {

163 int ufep=1;

164 /* H.263v2 */

165 /* H.263 Plus PTYPE */

166

167 put_bits(&s->pb, 3, 7);

168 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */

169 if (format == 8)

170 put_bits(&s->pb,3,6); /* Custom Source Format */

171 else

172 put_bits(&s->pb, 3, format);

173

174 put_bits(&s->pb,1, custom_pcf);

175 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */

176 put_bits(&s->pb,1,0); /* SAC: off */

177 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */

178 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */

179 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */

180 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */

181 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */

182 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */

183 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */

184 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */

185 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */

186 put_bits(&s->pb,3,0); /* Reserved */

187

188 put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);

189

190 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */

191 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */

192 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */

193 put_bits(&s->pb,2,0); /* Reserved */

194 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */

195

196 /* This should be here if PLUSPTYPE */

197 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */

198

199 if (format == 8) {

200 /* Custom Picture Format (CPFMT) */

201 unsigned aspect_ratio_info = ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);

202

203 put_bits(&s->pb,4, aspect_ratio_info);

204 put_bits(&s->pb,9,(s->width >> 2) - 1);

205 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */

206 put_bits(&s->pb,9,(s->height >> 2));

207 if (aspect_ratio_info == FF_ASPECT_EXTENDED){

208 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);

209 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);

210 }

211 }

212 if (custom_pcf) {

213 if(ufep){

214 put_bits(&s->pb, 1, best_clock_code);

215 put_bits(&s->pb, 7, best_divisor);

216 }

217 put_sbits(&s->pb, 2, temp_ref>>8);

218 }

219

220 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

221 if (s->umvplus)

222 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */

223 //FIXME check actual requested range

224 put_bits(&s->pb,2,1); /* unlimited */

225 if(s->h263_slice_structured)

226 put_bits(&s->pb,2,0); /* no weird submodes */

227

228 put_bits(&s->pb, 5, s->qscale);

229 }

230

231 put_bits(&s->pb, 1, 0); /* no PEI */

232

233 if(s->h263_slice_structured){

234 put_bits(&s->pb, 1, 1);

235

236 av_assert1(s->mb_x == 0 && s->mb_y == 0);

237 ff_h263_encode_mba(s);

238

239 put_bits(&s->pb, 1, 1);

240 }

241 }

242

243 /**

244 * Encode a group of blocks header.

245 */

246 void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)

247 {

248 put_bits(&s->pb, 17, 1); /* GBSC */

249

250 if(s->h263_slice_structured){

251 put_bits(&s->pb, 1, 1);

252

253 ff_h263_encode_mba(s);

254

255 if(s->mb_num > 1583)

256 put_bits(&s->pb, 1, 1);

257 put_bits(&s->pb, 5, s->qscale); /* GQUANT */

258 put_bits(&s->pb, 1, 1);

259 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */

260 }else{

261 int gob_number= mb_line / s->gob_index;

262

263 put_bits(&s->pb, 5, gob_number); /* GN */

264 put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */

265 put_bits(&s->pb, 5, s->qscale); /* GQUANT */

266 }

267 }

268

269 /**

270 * modify qscale so that encoding is actually possible in H.263 (limit difference to -2..2)

271 */

272 void ff_clean_h263_qscales(MpegEncContext *s){

273 int i;

274 int8_t * const qscale_table = s->current_picture.qscale_table;

275

276 ff_init_qscale_tab(s);

277

278 for(i=1; i<s->mb_num; i++){

279 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)

280 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;

281 }

282 for(i=s->mb_num-2; i>=0; i--){

283 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)

284 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;

285 }

286

287 if(s->codec_id != AV_CODEC_ID_H263P){

288 for(i=1; i<s->mb_num; i++){

289 int mb_xy= s->mb_index2xy[i];

290

291 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){

292 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;

293 }

294 }

295 }

296 }

297

298 static const int dquant_code[5]= {1,0,9,2,3};

299

300 /**

301 * Encode an 8x8 block.

302 * @param block the 8x8 block

303 * @param n block index (0-3 are luma, 4-5 are chroma)

304 */

305 static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)

306 {

307 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;

308 RLTable *rl;

309

310 rl = &ff_h263_rl_inter;

311 if (s->mb_intra && !s->h263_aic) {

312 /* DC coef */

313 level = block[0];

314 /* 255 cannot be represented, so we clamp */

315 if (level > 254) {

316 level = 254;

317 block[0] = 254;

318 }

319 /* 0 cannot be represented also */

320 else if (level < 1) {

321 level = 1;

322 block[0] = 1;

323 }

324 if (level == 128) //FIXME check rv10

325 put_bits(&s->pb, 8, 0xff);

326 else

327 put_bits(&s->pb, 8, level);

328 i = 1;

329 } else {

330 i = 0;

331 if (s->h263_aic && s->mb_intra)

332 rl = &ff_rl_intra_aic;

333

334 if(s->alt_inter_vlc && !s->mb_intra){

335 int aic_vlc_bits=0;

336 int inter_vlc_bits=0;

337 int wrong_pos=-1;

338 int aic_code;

339

340 last_index = s->block_last_index[n];

341 last_non_zero = i - 1;

342 for (; i <= last_index; i++) {

343 j = s->intra_scantable.permutated[i];

344 level = block[j];

345 if (level) {

346 run = i - last_non_zero - 1;

347 last = (i == last_index);

348

349 if(level<0) level= -level;

350

351 code = get_rl_index(rl, last, run, level);

352 aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);

353 inter_vlc_bits += rl->table_vlc[code][1]+1;

354 aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;

355

356 if (code == rl->n) {

357 inter_vlc_bits += 1+6+8-1;

358 }

359 if (aic_code == ff_rl_intra_aic.n) {

360 aic_vlc_bits += 1+6+8-1;

361 wrong_pos += run + 1;

362 }else

363 wrong_pos += wrong_run[aic_code];

364 last_non_zero = i;

365 }

366 }

367 i = 0;

368 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)

369 rl = &ff_rl_intra_aic;

370 }

371 }

372

373 /* AC coefs */

374 last_index = s->block_last_index[n];

375 last_non_zero = i - 1;

376 for (; i <= last_index; i++) {

377 j = s->intra_scantable.permutated[i];

378 level = block[j];

379 if (level) {

380 run = i - last_non_zero - 1;

381 last = (i == last_index);

382 sign = 0;

383 slevel = level;

384 if (level < 0) {

385 sign = 1;

386 level = -level;

387 }

388 code = get_rl_index(rl, last, run, level);

389 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);

390 if (code == rl->n) {

391 if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){

392 put_bits(&s->pb, 1, last);

393 put_bits(&s->pb, 6, run);

394

395 av_assert2(slevel != 0);

396

397 if(level < 128)

398 put_sbits(&s->pb, 8, slevel);

399 else{

400 put_bits(&s->pb, 8, 128);

401 put_sbits(&s->pb, 5, slevel);

402 put_sbits(&s->pb, 6, slevel>>5);

403 }

404 }else{

405 ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);

406 }

407 } else {

408 put_bits(&s->pb, 1, sign);

409 }

410 last_non_zero = i;

411 }

412 }

413 }

414

415 /* Encode MV differences on H.263+ with Unrestricted MV mode */

416 static void h263p_encode_umotion(PutBitContext *pb, int val)

417 {

418 short sval = 0;

419 short i = 0;

420 short n_bits = 0;

421 short temp_val;

422 int code = 0;

423 int tcode;

424

425 if ( val == 0)

426 put_bits(pb, 1, 1);

427 else if (val == 1)

428 put_bits(pb, 3, 0);

429 else if (val == -1)

430 put_bits(pb, 3, 2);

431 else {

432

433 sval = ((val < 0) ? (short)(-val):(short)val);

434 temp_val = sval;

435

436 while (temp_val != 0) {

437 temp_val = temp_val >> 1;

438 n_bits++;

439 }

440

441 i = n_bits - 1;

442 while (i > 0) {

443 tcode = (sval & (1 << (i-1))) >> (i-1);

444 tcode = (tcode << 1) | 1;

445 code = (code << 2) | tcode;

446 i--;

447 }

448 code = ((code << 1) | (val < 0)) << 1;

449 put_bits(pb, (2*n_bits)+1, code);

450 }

451 }

452

453 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)

454 {

455 int x, y, wrap, a, c, pred_dc;

456 int16_t *dc_val;

457

458 /* find prediction */

459 if (n < 4) {

460 x = 2 * s->mb_x + (n & 1);

461 y = 2 * s->mb_y + ((n & 2) >> 1);

462 wrap = s->b8_stride;

463 dc_val = s->dc_val[0];

464 } else {

465 x = s->mb_x;

466 y = s->mb_y;

467 wrap = s->mb_stride;

468 dc_val = s->dc_val[n - 4 + 1];

469 }

470 /* B C

471 * A X

472 */

473 a = dc_val[(x - 1) + (y) * wrap];

474 c = dc_val[(x) + (y - 1) * wrap];

475

476 /* No prediction outside GOB boundary */

477 if (s->first_slice_line && n != 3) {

478 if (n != 2) c = 1024;

479 if (n != 1 && s->mb_x == s->resync_mb_x) a = 1024;

480 }

481 /* just DC prediction */

482 if (a != 1024 && c != 1024)

483 pred_dc = (a + c) >> 1;

484 else if (a != 1024)

485 pred_dc = a;

486 else

487 pred_dc = c;

488

489 /* we assume pred is positive */

490 *dc_val_ptr = &dc_val[x + y * wrap];

491 return pred_dc;

492 }

493

494 void ff_h263_encode_mb(MpegEncContext * s,

495 int16_t block[6][64],

496 int motion_x, int motion_y)

497 {

498 int cbpc, cbpy, i, cbp, pred_x, pred_y;

499 int16_t pred_dc;

500 int16_t rec_intradc[6];

501 int16_t *dc_ptr[6];

502 const int interleaved_stats = s->avctx->flags & AV_CODEC_FLAG_PASS1;

503

504 if (!s->mb_intra) {

505 /* compute cbp */

506 cbp= get_p_cbp(s, block, motion_x, motion_y);

507

508 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {

509 /* skip macroblock */

510 put_bits(&s->pb, 1, 1);

511 if(interleaved_stats){

512 s->misc_bits++;

513 s->last_bits++;

514 }

515 s->skip_count++;

516

517 return;

518 }

519 put_bits(&s->pb, 1, 0); /* mb coded */

520

521 cbpc = cbp & 3;

522 cbpy = cbp >> 2;

523 if(s->alt_inter_vlc==0 || cbpc!=3)

524 cbpy ^= 0xF;

525 if(s->dquant) cbpc+= 8;

526 if(s->mv_type==MV_TYPE_16X16){

527 put_bits(&s->pb,

528 ff_h263_inter_MCBPC_bits[cbpc],

529 ff_h263_inter_MCBPC_code[cbpc]);

530

531 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);

532 if(s->dquant)

533 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);

534

535 if(interleaved_stats){

536 s->misc_bits+= get_bits_diff(s);

537 }

538

539 /* motion vectors: 16x16 mode */

540 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);

541

542 if (!s->umvplus) {

543 ff_h263_encode_motion_vector(s, motion_x - pred_x,

544 motion_y - pred_y, 1);

545 }

546 else {

547 h263p_encode_umotion(&s->pb, motion_x - pred_x);

548 h263p_encode_umotion(&s->pb, motion_y - pred_y);

549 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))

550 /* To prevent Start Code emulation */

551 put_bits(&s->pb,1,1);

552 }

553 }else{

554 put_bits(&s->pb,

555 ff_h263_inter_MCBPC_bits[cbpc+16],

556 ff_h263_inter_MCBPC_code[cbpc+16]);

557 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);

558 if(s->dquant)

559 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);

560

561 if(interleaved_stats){

562 s->misc_bits+= get_bits_diff(s);

563 }

564

565 for(i=0; i<4; i++){

566 /* motion vectors: 8x8 mode*/

567 ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);

568

569 motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];

570 motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];

571 if (!s->umvplus) {

572 ff_h263_encode_motion_vector(s, motion_x - pred_x,

573 motion_y - pred_y, 1);

574 }

575 else {

576 h263p_encode_umotion(&s->pb, motion_x - pred_x);

577 h263p_encode_umotion(&s->pb, motion_y - pred_y);

578 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))

579 /* To prevent Start Code emulation */

580 put_bits(&s->pb,1,1);

581 }

582 }

583 }

584

585 if(interleaved_stats){

586 s->mv_bits+= get_bits_diff(s);

587 }

588 } else {

589 av_assert2(s->mb_intra);

590

591 cbp = 0;

592 if (s->h263_aic) {

593 /* Predict DC */

594 for(i=0; i<6; i++) {

595 int16_t level = block[i][0];

596 int scale;

597

598 if(i<4) scale= s->y_dc_scale;

599 else scale= s->c_dc_scale;

600

601 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);

602 level -= pred_dc;

603 /* Quant */

604 if (level >= 0)

605 level = (level + (scale>>1))/scale;

606 else

607 level = (level - (scale>>1))/scale;

608

609 if(!s->modified_quant){

610 if (level < -127)

611 level = -127;

612 else if (level > 127)

613 level = 127;

614 }

615

616 block[i][0] = level;

617 /* Reconstruction */

618 rec_intradc[i] = scale*level + pred_dc;

619 /* Oddify */

620 rec_intradc[i] |= 1;

621 //if ((rec_intradc[i] % 2) == 0)

622 // rec_intradc[i]++;

623 /* Clipping */

624 if (rec_intradc[i] < 0)

625 rec_intradc[i] = 0;

626 else if (rec_intradc[i] > 2047)

627 rec_intradc[i] = 2047;

628

629 /* Update AC/DC tables */

630 *dc_ptr[i] = rec_intradc[i];

631 /* AIC can change CBP */

632 if (s->block_last_index[i] > 0 ||

633 (s->block_last_index[i] == 0 && level !=0))

634 cbp |= 1 << (5 - i);

635 }

636 }else{

637 for(i=0; i<6; i++) {

638 /* compute cbp */

639 if (s->block_last_index[i] >= 1)

640 cbp |= 1 << (5 - i);

641 }

642 }

643

644 cbpc = cbp & 3;

645 if (s->pict_type == AV_PICTURE_TYPE_I) {

646 if(s->dquant) cbpc+=4;

647 put_bits(&s->pb,

648 ff_h263_intra_MCBPC_bits[cbpc],

649 ff_h263_intra_MCBPC_code[cbpc]);

650 } else {

651 if(s->dquant) cbpc+=8;

652 put_bits(&s->pb, 1, 0); /* mb coded */

653 put_bits(&s->pb,

654 ff_h263_inter_MCBPC_bits[cbpc + 4],

655 ff_h263_inter_MCBPC_code[cbpc + 4]);

656 }

657 if (s->h263_aic) {

658 /* XXX: currently, we do not try to use ac prediction */

659 put_bits(&s->pb, 1, 0); /* no AC prediction */

660 }

661 cbpy = cbp >> 2;

662 put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);

663 if(s->dquant)

664 put_bits(&s->pb, 2, dquant_code[s->dquant+2]);

665

666 if(interleaved_stats){

667 s->misc_bits+= get_bits_diff(s);

668 }

669 }

670

671 for(i=0; i<6; i++) {

672 /* encode each block */

673 h263_encode_block(s, block[i], i);

674

675 /* Update INTRADC for decoding */

676 if (s->h263_aic && s->mb_intra) {

677 block[i][0] = rec_intradc[i];

678

679 }

680 }

681

682 if(interleaved_stats){

683 if (!s->mb_intra) {

684 s->p_tex_bits+= get_bits_diff(s);

685 }else{

686 s->i_tex_bits+= get_bits_diff(s);

687 s->i_count++;

688 }

689 }

690 }

691

692 void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)

693 {

694 int range, bit_size, sign, code, bits;

695

696 if (val == 0) {

697 /* zero vector */

698 code = 0;

699 put_bits(pb, ff_mvtab[code][1], ff_mvtab[code][0]);

700 } else {

701 bit_size = f_code - 1;

702 range = 1 << bit_size;

703 /* modulo encoding */

704 val = sign_extend(val, 6 + bit_size);

705 sign = val>>31;

706 val= (val^sign)-sign;

707 sign&=1;

708

709 val--;

710 code = (val >> bit_size) + 1;

711 bits = val & (range - 1);

712

713 put_bits(pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);

714 if (bit_size > 0) {

715 put_bits(pb, bit_size, bits);

716 }

717 }

718 }

719

720 static av_cold void init_mv_penalty_and_fcode(void)

721 {

722 int f_code;

723 int mv;

724

725 for(f_code=1; f_code<=MAX_FCODE; f_code++){

726 for(mv=-MAX_DMV; mv<=MAX_DMV; mv++){

727 int len;

728

729 if(mv==0) len= ff_mvtab[0][1];

730 else{

731 int val, bit_size, code;

732

733 bit_size = f_code - 1;

734

735 val=mv;

736 if (val < 0)

737 val = -val;

738 val--;

739 code = (val >> bit_size) + 1;

740 if(code<33){

741 len= ff_mvtab[code][1] + 1 + bit_size;

742 }else{

743 len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;

744 }

745 }

746

747 mv_penalty[f_code][mv+MAX_DMV]= len;

748 }

749 }

750

751 for(f_code=MAX_FCODE; f_code>0; f_code--){

752 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){

753 fcode_tab[mv+MAX_MV]= f_code;

754 }

755 }

756

757 for(mv=0; mv<MAX_MV*2+1; mv++){

758 umv_fcode_tab[mv]= 1;

759 }

760 }

761

762 static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)

763 {

764 int slevel, run, last;

765

766 av_assert0(MAX_LEVEL >= 64);

767 av_assert0(MAX_RUN >= 63);

768

769 for(slevel=-64; slevel<64; slevel++){

770 if(slevel==0) continue;

771 for(run=0; run<64; run++){

772 for(last=0; last<=1; last++){

773 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);

774 int level= slevel < 0 ? -slevel : slevel;

775 int sign= slevel < 0 ? 1 : 0;

776 int bits, len, code;

777

778 len_tab[index]= 100;

779

780 /* ESC0 */

781 code= get_rl_index(rl, last, run, level);

782 bits= rl->table_vlc[code][0];

783 len= rl->table_vlc[code][1];

784 bits=bits*2+sign; len++;

785

786 if (code != rl->n && len < len_tab[index])

787 len_tab [index]= len;

788

789 /* ESC */

790 bits= rl->table_vlc[rl->n][0];

791 len = rl->table_vlc[rl->n][1];

792 bits=bits*2+last; len++;

793 bits=bits*64+run; len+=6;

794 bits=bits*256+(level&0xff); len+=8;

795

796 if (len < len_tab[index])

797 len_tab [index]= len;

798 }

799 }

800 }

801 }

802

803 static av_cold void h263_encode_init_static(void)

804 {

805 static uint8_t rl_intra_table[2][2 * MAX_RUN + MAX_LEVEL + 3];

806

807 ff_rl_init(&ff_rl_intra_aic, rl_intra_table);

808 ff_h263_init_rl_inter();

809

810 init_uni_h263_rl_tab(&ff_rl_intra_aic, uni_h263_intra_aic_rl_len);

811 init_uni_h263_rl_tab(&ff_h263_rl_inter, uni_h263_inter_rl_len);

812

813 init_mv_penalty_and_fcode();

814 }

815

816 av_cold void ff_h263_encode_init(MpegEncContext *s)

817 {

818 static AVOnce init_static_once = AV_ONCE_INIT;

819

820 s->me.mv_penalty= mv_penalty; // FIXME exact table for MSMPEG4 & H.263+

821

822 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;

823 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;

824 if(s->h263_aic){

825 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;

826 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;

827 }

828 s->ac_esc_length= 7+1+6+8;

829

830 // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME

831 switch(s->codec_id){

832 case AV_CODEC_ID_MPEG4:

833 s->fcode_tab= fcode_tab;

834 break;

835 case AV_CODEC_ID_H263P:

836 if(s->umvplus)

837 s->fcode_tab= umv_fcode_tab;

838 if(s->modified_quant){

839 s->min_qcoeff= -2047;

840 s->max_qcoeff= 2047;

841 }else{

842 s->min_qcoeff= -127;

843 s->max_qcoeff= 127;

844 }

845 break;

846 // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later

847 case AV_CODEC_ID_FLV1:

848 if (s->h263_flv > 1) {

849 s->min_qcoeff= -1023;

850 s->max_qcoeff= 1023;

851 } else {

852 s->min_qcoeff= -127;

853 s->max_qcoeff= 127;

854 }

855 break;

856 default: //nothing needed - default table already set in mpegvideo.c

857 s->min_qcoeff= -127;

858 s->max_qcoeff= 127;

859 }

860 if(s->h263_aic){

861 s->y_dc_scale_table=

862 s->c_dc_scale_table= ff_aic_dc_scale_table;

863 }else{

864 s->y_dc_scale_table=

865 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;

866 }

867

868 if (s->lmin > s->lmax) {

869 av_log(s->avctx, AV_LOG_WARNING, "Clipping lmin value to %d\n", s->lmax);

870 s->lmin = s->lmax;

871 }

872

873 ff_thread_once(&init_static_once, h263_encode_init_static);

874 }

875

876 void ff_h263_encode_mba(MpegEncContext *s)

877 {

878 int i, mb_pos;

879

880 for(i=0; i<6; i++){

881 if(s->mb_num-1 <= ff_mba_max[i]) break;

882 }

883 mb_pos= s->mb_x + s->mb_width*s->mb_y;

884 put_bits(&s->pb, ff_mba_length[i], mb_pos);

885 }

886

887 #define OFFSET(x) offsetof(MpegEncContext, x)

888 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

889 static const AVOption h263_options[] = {

890 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },

891 { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },

892 FF_MPV_COMMON_OPTS

893 FF_MPV_COMMON_MOTION_EST_OPTS

894 { NULL },

895 };

896

897 static const AVClass h263_class = {

898 .class_name = "H.263 encoder",

899 .item_name = av_default_item_name,

900 .option = h263_options,

901 .version = LIBAVUTIL_VERSION_INT,

902 };

903

904 const FFCodec ff_h263_encoder = {

905 .p.name = "h263",

906 CODEC_LONG_NAME("H.263 / H.263-1996"),

907 .p.type = AVMEDIA_TYPE_VIDEO,

908 .p.id = AV_CODEC_ID_H263,

909 .p.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},

910 .p.priv_class = &h263_class,

911 .p.capabilities = AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

912 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

913 .priv_data_size = sizeof(MpegEncContext),

914 .init = ff_mpv_encode_init,

915 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),

916 .close = ff_mpv_encode_end,

917 };

918

919 static const AVOption h263p_options[] = {

920 { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },

921 { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },

922 { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },

923 { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},

924 FF_MPV_COMMON_OPTS

925 FF_MPV_COMMON_MOTION_EST_OPTS

926 { NULL },

927 };

928 static const AVClass h263p_class = {

929 .class_name = "H.263p encoder",

930 .item_name = av_default_item_name,

931 .option = h263p_options,

932 .version = LIBAVUTIL_VERSION_INT,

933 };

934

935 const FFCodec ff_h263p_encoder = {

936 .p.name = "h263p",

937 CODEC_LONG_NAME("H.263+ / H.263-1998 / H.263 version 2"),

938 .p.type = AVMEDIA_TYPE_VIDEO,

939 .p.id = AV_CODEC_ID_H263P,

940 .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },

941 .p.priv_class = &h263p_class,

942 .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

943 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

944 .priv_data_size = sizeof(MpegEncContext),

945 .init = ff_mpv_encode_init,

946 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),

947 .close = ff_mpv_encode_end,

948 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

MV_TYPE_16X16

#define MV_TYPE_16X16

1 vector for the whole mb

Definition: mpegvideo.h:261

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

h263data.h

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

FF_ASPECT_EXTENDED

#define FF_ASPECT_EXTENDED

Definition: h263.h:26

level

uint8_t level

Definition: svq3.c:204

av_clip

#define av_clip

Definition: common.h:98

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:42

get_bits_diff

static int get_bits_diff(MpegEncContext *s)

Definition: mpegvideoenc.h:139

wrong_run

static const uint8_t wrong_run[102]

Definition: ituh263enc.c:73

fcode_tab

static uint8_t fcode_tab[MAX_MV *2+1]

Minimal fcode that a motion vector component would need.

Definition: ituh263enc.c:57

align_put_bits

static void align_put_bits(PutBitContext *s)

Pad the bitstream with zeros up to the next byte boundary.

Definition: put_bits.h:420

uni_h263_inter_rl_len

static uint8_t uni_h263_inter_rl_len[64 *64 *2 *2]

Definition: ituh263enc.c:68

UNI_MPEG4_ENC_INDEX

#define UNI_MPEG4_ENC_INDEX(last, run, level)

Definition: ituh263enc.c:71

h263p_options

static const AVOption h263p_options[]

Definition: ituh263enc.c:919

thread.h

#define VE

Definition: ituh263enc.c:888

mpegvideoenc.h

int64_t

long long int64_t

Definition: coverity.c:34

static const int8_t mv[256][2]

Definition: 4xm.c:80

put_sbits

static void put_sbits(PutBitContext *pb, int n, int32_t value)

Definition: put_bits.h:281

MAX_RUN

#define MAX_RUN

Definition: rl.h:35

h263enc.h

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:222

MAX_DMV

#define MAX_DMV

Definition: motion_est.h:37

internal.h

av_const

#define av_const

Definition: attributes.h:84

AVOption

AVOption.

Definition: opt.h:346

OFFSET

#define OFFSET(x)

Definition: ituh263enc.c:887

FFCodec

Definition: codec_internal.h:127

init_uni_h263_rl_tab

static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)

Definition: ituh263enc.c:762

mpegvideo.h

CANDIDATE_MB_TYPE_INTER

#define CANDIDATE_MB_TYPE_INTER

Definition: mpegutils.h:98

mpegutils.h

h263_pred_dc

static int h263_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr)

Definition: ituh263enc.c:453

FF_MPV_COMMON_MOTION_EST_OPTS

#define FF_MPV_COMMON_MOTION_EST_OPTS

Definition: mpegvideoenc.h:108

MAX_FCODE

#define MAX_FCODE

Definition: mpegutils.h:41

ff_mpv_encode_picture

int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)

Definition: mpegvideo_enc.c:1756

FF_MPV_COMMON_OPTS

#define FF_MPV_COMMON_OPTS

Definition: mpegvideoenc.h:65

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

h263p_class

static const AVClass h263p_class

Definition: ituh263enc.c:928

ff_match_2uint16

int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)

Return the index into tab at which {a,b} match elements {[0],[1]} of tab.

Definition: utils.c:834

ff_h263_pred_motion

int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)

Definition: h263.c:190

wrap

#define wrap(func)

Definition: neontest.h:65

ff_h263_pixel_aspect

const AVRational ff_h263_pixel_aspect[16]

Definition: h263data.c:273

RLTable

RLTable.

Definition: rl.h:39

mv_penalty

static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]

Table of number of bits a motion vector component needs.

Definition: ituh263enc.c:52

val

static double val(void *priv, double ch)

Definition: aeval.c:78

ff_h263_encode_motion_vector

static void ff_h263_encode_motion_vector(MpegEncContext *s, int x, int y, int f_code)

Definition: h263enc.h:60

ff_h263_aspect_to_info

av_const int ff_h263_aspect_to_info(AVRational aspect)

Return the 4 bit value that specifies the given aspect ratio.

Definition: ituh263enc.c:94

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:296

AVRational::num

int num

Numerator.

Definition: rational.h:59

CANDIDATE_MB_TYPE_INTER4V

#define CANDIDATE_MB_TYPE_INTER4V

Definition: mpegutils.h:99

h263_encode_block

static void h263_encode_block(MpegEncContext *s, int16_t *block, int n)

Encode an 8x8 block.

Definition: ituh263enc.c:305

RLTable::n

int n

number of entries of table_vlc minus 1

Definition: rl.h:40

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

ff_h263_encode_motion

void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)

Definition: ituh263enc.c:692

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

MAX_MV

#define MAX_MV

Definition: motion_est.h:35

#define s(width, name)

Definition: cbs_vp9.c:198

format

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists

get_rl_index

static int get_rl_index(const RLTable *rl, int last, int run, int level)

Definition: rl.h:101

get_p_cbp

static int get_p_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)

Definition: h263enc.h:73

AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...

Definition: codec.h:159

ff_mpeg1_dc_scale_table

static const uint8_t *const ff_mpeg1_dc_scale_table

Definition: mpegvideodata.h:32

bits

uint8_t bits

Definition: vp3data.h:128

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

limits.h

ff_h263p_encoder

const FFCodec ff_h263p_encoder

Definition: ituh263enc.c:935

ff_h263_encode_init

av_cold void ff_h263_encode_init(MpegEncContext *s)

Definition: ituh263enc.c:816

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

PutBitContext

Definition: put_bits.h:50

ff_rl_init

av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])

Initialize index_run, max_level and max_run from n, last, table_vlc, table_run and table_level.

Definition: rl.c:44

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

ff_h263_encode_mb

void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)

Definition: ituh263enc.c:494

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:72

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

init_mv_penalty_and_fcode

static av_cold void init_mv_penalty_and_fcode(void)

Definition: ituh263enc.c:720

run

uint8_t run

Definition: svq3.c:203

RLTable::table_vlc

const uint16_t(* table_vlc)[2]

Definition: rl.h:42

ff_h263_encoder

const FFCodec ff_h263_encoder

Definition: ituh263enc.c:904

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

uni_h263_intra_aic_rl_len

static uint8_t uni_h263_intra_aic_rl_len[64 *64 *2 *2]

Definition: ituh263enc.c:67

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:279

mathops.h

ff_mba_max

const uint16_t ff_mba_max[6]

Definition: h263data.c:265

ff_mpv_encode_end

av_cold int ff_mpv_encode_end(AVCodecContext *avctx)

Definition: mpegvideo_enc.c:987

ff_init_qscale_tab

void ff_init_qscale_tab(MpegEncContext *s)

init s->current_picture.qscale_table from s->lambda_table

Definition: mpegvideo_enc.c:235

AVOnce

#define AVOnce

Definition: thread.h:202

index

int index

Definition: gxfenc.c:89

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

MAX_LEVEL

#define MAX_LEVEL

Definition: rl.h:36

ff_clean_h263_qscales

void ff_clean_h263_qscales(MpegEncContext *s)

modify qscale so that encoding is actually possible in H.263 (limit difference to -2....

Definition: ituh263enc.c:272

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:365

ff_h263_rl_inter

RLTable ff_h263_rl_inter

Definition: h263data.c:159

scale

static void scale(int *out, const int *in, const int w, const int h, const int shift)

Definition: vvc_intra.c:291

codec_internal.h

AV_CODEC_ID_H263

@ AV_CODEC_ID_H263

Definition: codec_id.h:56

ff_h263_cbpy_tab

const uint8_t ff_h263_cbpy_tab[16][2]

Definition: h263data.c:82

ff_rl_intra_aic

RLTable ff_rl_intra_aic

Definition: h263data.c:228

range

enum AVColorRange range

Definition: mediacodec_wrapper.c:2557

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

AV_CODEC_CAP_SLICE_THREADS

#define AV_CODEC_CAP_SLICE_THREADS

Codec supports slice-based (or partition-based) multithreading.

Definition: codec.h:114

mpegvideodata.h

attributes.h

ff_h263_inter_MCBPC_bits

const uint8_t ff_h263_inter_MCBPC_bits[28]

Definition: h263data.c:47

h263_options

static const AVOption h263_options[]

Definition: ituh263enc.c:889

ff_h263_encode_picture_header

void ff_h263_encode_picture_header(MpegEncContext *s)

Definition: ituh263enc.c:108

av_assert2

#define av_assert2(cond)

assert() equivalent, that does lie in speed critical code.

Definition: avassert.h:67

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:255

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:56

ff_h263_format

const uint16_t ff_h263_format[8][2]

Definition: h263data.c:236

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194