FFmpeg: libavcodec/dv.c Source File

FFmpeg

[フレーム]

libavcodec

dv.c

Go to the documentation of this file.

1 /*

2 * DV decoder

5 *

6 * DV encoder

8 *

9 * 50 Mbps (DVCPRO50) support

11 *

12 * 100 Mbps (DVCPRO HD) support

13 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)

14 * Final code by Roman Shaposhnik

15 *

16 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth

17 * of DV technical info.

18 *

19 * This file is part of FFmpeg.

20 *

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

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

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

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

25 *

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

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

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

29 * Lesser General Public License for more details.

30 *

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

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

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

34 */

36 /**

37 * @file

38 * DV codec.

39 */

41 #include "libavutil/internal.h"

42 #include "libavutil/pixdesc.h"

43 #include "avcodec.h"

44 #include "get_bits.h"

45 #include "internal.h"

46 #include "put_bits.h"

47 #include "simple_idct.h"

48 #include "dvdata.h"

49 #include "dv_tablegen.h"

51 /* XXX: also include quantization */

52 RL_VLC_ELEM ff_dv_rl_vlc[1184];

54 static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,

55 uint16_t *tbl)

56 {

57 static const uint8_t off[] = { 2, 6, 8, 0, 4 };

58 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };

59 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };

60 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };

62 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};

63 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };

65 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,

66 0, 1, 2, 2, 1, 0,

67 0, 1, 2, 2, 1, 0,

68 0, 1, 2, 2, 1, 0,

69 0, 1, 2};

70 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,

71 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,

72 0, 1, 2, 3, 4, 5};

74 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */

75 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},

76 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},

77 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},

78 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},

79 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},

80 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},

81 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},

82 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},

83 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},

84 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},

85 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},

86 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};

88 int i, k, m;

89 int x, y, blk;

91 for (m=0; m<5; m++) {

92 switch (d->width) {

93 case 1440:

94 blk = (chan*11+seq)*27+slot;

96 if (chan == 0 && seq == 11) {

97 x = m*27+slot;

98 if (x<90) {

99 y = 0;

100 } else {

101 x = (x - 90)*2;

102 y = 67;

103 }

104 } else {

105 i = (4*chan + blk + off[m])%11;

106 k = (blk/11)%27;

107

108 x = shuf1[m] + (chan&1)*9 + k%9;

109 y = (i*3+k/9)*2 + (chan>>1) + 1;

110 }

111 tbl[m] = (x<<1)|(y<<9);

112 break;

113 case 1280:

114 blk = (chan*10+seq)*27+slot;

115

116 i = (4*chan + (seq/5) + 2*blk + off[m])%10;

117 k = (blk/5)%27;

118

119 x = shuf1[m]+(chan&1)*9 + k%9;

120 y = (i*3+k/9)*2 + (chan>>1) + 4;

121

122 if (x >= 80) {

123 x = remap[y][0]+((x-80)<<(y>59));

124 y = remap[y][1];

125 }

126 tbl[m] = (x<<1)|(y<<9);

127 break;

128 case 960:

129 blk = (chan*10+seq)*27+slot;

130

131 i = (4*chan + (seq/5) + 2*blk + off[m])%10;

132 k = (blk/5)%27 + (i&1)*3;

133

134 x = shuf2[m] + k%6 + 6*(chan&1);

135 y = l_start[i] + k/6 + 45*(chan>>1);

136 tbl[m] = (x<<1)|(y<<9);

137 break;

138 case 720:

139 switch (d->pix_fmt) {

140 case AV_PIX_FMT_YUV422P:

141 x = shuf3[m] + slot/3;

142 y = serpent1[slot] +

143 ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;

144 tbl[m] = (x<<1)|(y<<8);

145 break;

146 case AV_PIX_FMT_YUV420P:

147 x = shuf3[m] + slot/3;

148 y = serpent1[slot] +

149 ((seq + off[m]) % d->difseg_size)*3;

150 tbl[m] = (x<<1)|(y<<9);

151 break;

152 case AV_PIX_FMT_YUV411P:

153 i = (seq + off[m]) % d->difseg_size;

154 k = slot + ((m==1||m==2)?3:0);

155

156 x = l_start_shuffled[m] + k/6;

157 y = serpent2[k] + i*6;

158 if (x>21)

159 y = y*2 - i*6;

160 tbl[m] = (x<<2)|(y<<8);

161 break;

162 }

163 default:

164 break;

165 }

166 }

167 }

168

169 /* quantization quanta by QNO for DV100 */

170 static const uint8_t dv100_qstep[16] = {

171 1, /* QNO = 0 and 1 both have no quantization */

172 1,

173 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52

174 };

175

176 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };

177

178 int ff_dv_init_dynamic_tables(const DVprofile *d)

179 {

180 int j,i,c,s,p;

181 uint32_t *factor1, *factor2;

182 const int *iweight1, *iweight2;

183

184 if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {

185 p = i = 0;

186 for (c=0; c<d->n_difchan; c++) {

187 for (s=0; s<d->difseg_size; s++) {

188 p += 6;

189 for (j=0; j<27; j++) {

190 p += !(j%3);

191 if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&

192 !(DV_PROFILE_IS_720p50(d) && s > 9)) {

193 dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);

194 d->work_chunks[i++].buf_offset = p;

195 }

196 p += 5;

197 }

198 }

199 }

200 }

201

202 if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {

203 factor1 = &d->idct_factor[0];

204 factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];

205 if (d->height == 720) {

206 iweight1 = &ff_dv_iweight_720_y[0];

207 iweight2 = &ff_dv_iweight_720_c[0];

208 } else {

209 iweight1 = &ff_dv_iweight_1080_y[0];

210 iweight2 = &ff_dv_iweight_1080_c[0];

211 }

212 if (DV_PROFILE_IS_HD(d)) {

213 for (c = 0; c < 4; c++) {

214 for (s = 0; s < 16; s++) {

215 for (i = 0; i < 64; i++) {

216 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];

217 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];

218 }

219 }

220 }

221 } else {

222 iweight1 = &ff_dv_iweight_88[0];

223 for (j = 0; j < 2; j++, iweight1 = &ff_dv_iweight_248[0]) {

224 for (s = 0; s < 22; s++) {

225 for (i = c = 0; c < 4; c++) {

226 for (; i < dv_quant_areas[c]; i++) {

227 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);

228 *factor2++ = (*factor1++) << 1;

229 }

230 }

231 }

232 }

233 }

234 }

235

236 return 0;

237 }

238

239 av_cold int ff_dvvideo_init(AVCodecContext *avctx)

240 {

241 DVVideoContext *s = avctx->priv_data;

242 DSPContext dsp;

243 static int done = 0;

244 int i, j;

245

246 if (!done) {

247 VLC dv_vlc;

248 uint16_t new_dv_vlc_bits[NB_DV_VLC*2];

249 uint8_t new_dv_vlc_len[NB_DV_VLC*2];

250 uint8_t new_dv_vlc_run[NB_DV_VLC*2];

251 int16_t new_dv_vlc_level[NB_DV_VLC*2];

252

253 done = 1;

254

255 /* it's faster to include sign bit in a generic VLC parsing scheme */

256 for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {

257 new_dv_vlc_bits[j] = dv_vlc_bits[i];

258 new_dv_vlc_len[j] = dv_vlc_len[i];

259 new_dv_vlc_run[j] = dv_vlc_run[i];

260 new_dv_vlc_level[j] = dv_vlc_level[i];

261

262 if (dv_vlc_level[i]) {

263 new_dv_vlc_bits[j] <<= 1;

264 new_dv_vlc_len[j]++;

265

266 j++;

267 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;

268 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;

269 new_dv_vlc_run[j] = dv_vlc_run[i];

270 new_dv_vlc_level[j] = -dv_vlc_level[i];

271 }

272 }

273

274 /* NOTE: as a trick, we use the fact the no codes are unused

275 to accelerate the parsing of partial codes */

276 init_vlc(&dv_vlc, TEX_VLC_BITS, j,

277 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);

278 av_assert1(dv_vlc.table_size == 1184);

279

280 for (i = 0; i < dv_vlc.table_size; i++){

281 int code = dv_vlc.table[i][0];

282 int len = dv_vlc.table[i][1];

283 int level, run;

284

285 if (len < 0){ //more bits needed

286 run = 0;

287 level = code;

288 } else {

289 run = new_dv_vlc_run [code] + 1;

290 level = new_dv_vlc_level[code];

291 }

292 ff_dv_rl_vlc[i].len = len;

293 ff_dv_rl_vlc[i].level = level;

294 ff_dv_rl_vlc[i].run = run;

295 }

296 ff_free_vlc(&dv_vlc);

297 }

298

299 /* Generic DSP setup */

300 memset(&dsp,0, sizeof(dsp));

301 ff_dsputil_init(&dsp, avctx);

302 ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);

303 s->get_pixels = dsp.get_pixels;

304 s->ildct_cmp = dsp.ildct_cmp[5];

305

306 /* 88DCT setup */

307 s->fdct[0] = dsp.fdct;

308 s->idct_put[0] = dsp.idct_put;

309 for (i = 0; i < 64; i++)

310 s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];

311

312 /* 248DCT setup */

313 s->fdct[1] = dsp.fdct248;

314 s->idct_put[1] = ff_simple_idct248_put; // FIXME: need to add it to DSP

315 if (avctx->lowres){

316 for (i = 0; i < 64; i++){

317 int j = ff_zigzag248_direct[i];

318 s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];

319 }

320 }else

321 memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);

322

323 avcodec_get_frame_defaults(&s->picture);

324 avctx->coded_frame = &s->picture;

325 s->avctx = avctx;

326 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;

327

328 return 0;

329 }

330

331 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)

332 {

333 if (!avpriv_dv_codec_profile(avctx)) {

334 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "

335 "Valid DV profiles are:\n",

336 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));

337 ff_dv_print_profiles(avctx, AV_LOG_ERROR);

338 return AVERROR(EINVAL);

339 }

340 if (avctx->height > 576) {

341 av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");

342 return AVERROR_PATCHWELCOME;

343 }

344

345 dv_vlc_map_tableinit();

346

347 return ff_dvvideo_init(avctx);

348 }

349

350 /* bit budget for AC only in 5 MBs */

351 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;

352 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };

353

354 #if CONFIG_SMALL

355 /* Converts run and level (where level != 0) pair into VLC, returning bit size */

356 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)

357 {

358 int size;

359 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

360 *vlc = dv_vlc_map[run][level].vlc | sign;

361 size = dv_vlc_map[run][level].size;

362 }

363 else {

364 if (level < DV_VLC_MAP_LEV_SIZE) {

365 *vlc = dv_vlc_map[0][level].vlc | sign;

366 size = dv_vlc_map[0][level].size;

367 } else {

368 *vlc = 0xfe00 | (level << 1) | sign;

369 size = 16;

370 }

371 if (run) {

372 *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :

373 (0x1f80 | (run - 1))) << size;

374 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;

375 }

376 }

377

378 return size;

379 }

380

381 static av_always_inline int dv_rl2vlc_size(int run, int level)

382 {

383 int size;

384

385 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {

386 size = dv_vlc_map[run][level].size;

387 }

388 else {

389 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;

390 if (run) {

391 size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;

392 }

393 }

394 return size;

395 }

396 #else

397 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)

398 {

399 *vlc = dv_vlc_map[run][l].vlc | sign;

400 return dv_vlc_map[run][l].size;

401 }

402

403 static av_always_inline int dv_rl2vlc_size(int run, int l)

404 {

405 return dv_vlc_map[run][l].size;

406 }

407 #endif

408

409 typedef struct EncBlockInfo {

410 int area_q[4];

411 int bit_size[4];

412 int prev[5];

413 int cur_ac;

414 int cno;

415 int dct_mode;

416 int16_t mb[64];

417 uint8_t next[64];

418 uint8_t sign[64];

419 uint8_t partial_bit_count;

420 uint32_t partial_bit_buffer; /* we can't use uint16_t here */

421 } EncBlockInfo;

422

423 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,

424 PutBitContext* pb_pool,

425 PutBitContext* pb_end)

426 {

427 int prev, bits_left;

428 PutBitContext* pb = pb_pool;

429 int size = bi->partial_bit_count;

430 uint32_t vlc = bi->partial_bit_buffer;

431

432 bi->partial_bit_count = bi->partial_bit_buffer = 0;

433 for (;;){

434 /* Find suitable storage space */

435 for (; size > (bits_left = put_bits_left(pb)); pb++) {

436 if (bits_left) {

437 size -= bits_left;

438 put_bits(pb, bits_left, vlc >> size);

439 vlc = vlc & ((1 << size) - 1);

440 }

441 if (pb + 1 >= pb_end) {

442 bi->partial_bit_count = size;

443 bi->partial_bit_buffer = vlc;

444 return pb;

445 }

446 }

447

448 /* Store VLC */

449 put_bits(pb, size, vlc);

450

451 if (bi->cur_ac >= 64)

452 break;

453

454 /* Construct the next VLC */

455 prev = bi->cur_ac;

456 bi->cur_ac = bi->next[prev];

457 if (bi->cur_ac < 64){

458 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);

459 } else {

460 size = 4; vlc = 6; /* End Of Block stamp */

461 }

462 }

463 return pb;

464 }

465

466 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {

467 if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {

468 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;

469 if (ps > 0) {

470 int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +

471 s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);

472 return ps > is;

473 }

474 }

475

476 return 0;

477 }

478

479 static const int dv_weight_bits = 18;

480 static const int dv_weight_88[64] = {

481 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,

482 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,

483 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,

484 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,

485 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,

486 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,

487 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,

488 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,

489 };

490 static const int dv_weight_248[64] = {

491 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,

492 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,

493 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,

494 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,

495 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,

496 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,

497 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,

498 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,

499 };

500

501 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)

502 {

503 const int *weight;

504 const uint8_t* zigzag_scan;

505 LOCAL_ALIGNED_16(int16_t, blk, [64]);

506 int i, area;

507 /* We offer two different methods for class number assignment: the

508 method suggested in SMPTE 314M Table 22, and an improved

509 method. The SMPTE method is very conservative; it assigns class

510 3 (i.e. severe quantization) to any block where the largest AC

511 component is greater than 36. FFmpeg's DV encoder tracks AC bit

512 consumption precisely, so there is no need to bias most blocks

513 towards strongly lossy compression. Instead, we assign class 2

514 to most blocks, and use class 3 only when strictly necessary

515 (for blocks whose largest AC component exceeds 255). */

516

517 #if 0 /* SMPTE spec method */

518 static const int classes[] = {12, 24, 36, 0xffff};

519 #else /* improved FFmpeg method */

520 static const int classes[] = {-1, -1, 255, 0xffff};

521 #endif

522 int max = classes[0];

523 int prev = 0;

524

525 av_assert2((((int)blk) & 15) == 0);

526

527 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;

528 bi->partial_bit_count = 0;

529 bi->partial_bit_buffer = 0;

530 bi->cur_ac = 0;

531 if (data) {

532 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);

533 s->get_pixels(blk, data, linesize);

534 s->fdct[bi->dct_mode](blk);

535 } else {

536 /* We rely on the fact that encoding all zeros leads to an immediate EOB,

537 which is precisely what the spec calls for in the "dummy" blocks. */

538 memset(blk, 0, 64*sizeof(*blk));

539 bi->dct_mode = 0;

540 }

541 bi->mb[0] = blk[0];

542

543 zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;

544 weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;

545

546 for (area = 0; area < 4; area++) {

547 bi->prev[area] = prev;

548 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)

549 for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {

550 int level = blk[zigzag_scan[i]];

551

552 if (level + 15 > 30U) {

553 bi->sign[i] = (level >> 31) & 1;

554 /* weight it and and shift down into range, adding for rounding */

555 /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT

556 AND the 2x doubling of the weights */

557 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);

558 bi->mb[i] = level;

559 if (level > max)

560 max = level;

561 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);

562 bi->next[prev]= i;

563 prev = i;

564 }

565 }

566 }

567 bi->next[prev]= i;

568 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);

569

570 bi->cno += bias;

571

572 if (bi->cno >= 3) {

573 bi->cno = 3;

574 prev = 0;

575 i = bi->next[prev];

576 for (area = 0; area < 4; area++) {

577 bi->prev[area] = prev;

578 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)

579 for (; i < mb_area_start[area+1]; i = bi->next[i]) {

580 bi->mb[i] >>= 1;

581

582 if (bi->mb[i]) {

583 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);

584 bi->next[prev]= i;

585 prev = i;

586 }

587 }

588 }

589 bi->next[prev]= i;

590 }

591

592 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];

593 }

594

595 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)

596 {

597 int size[5];

598 int i, j, k, a, prev, a2;

599 EncBlockInfo* b;

600

601 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;

602 do {

603 b = blks;

604 for (i = 0; i < 5; i++) {

605 if (!qnos[i])

606 continue;

607

608 qnos[i]--;

609 size[i] = 0;

610 for (j = 0; j < 6; j++, b++) {

611 for (a = 0; a < 4; a++) {

612 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {

613 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)

614 b->area_q[a]++;

615 prev = b->prev[a];

616 av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);

617 for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {

618 b->mb[k] >>= 1;

619 if (b->mb[k]) {

620 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);

621 prev = k;

622 } else {

623 if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){

624 for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)

625 b->prev[a2] = prev;

626 av_assert2(a2 < 4);

627 av_assert2(b->mb[b->next[k]]);

628 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])

629 -dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);

630 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));

631 b->prev[a2] = prev;

632 }

633 b->next[prev] = b->next[k];

634 }

635 }

636 b->prev[a+1]= prev;

637 }

638 size[i] += b->bit_size[a];

639 }

640 }

641 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])

642 return;

643 }

644 } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);

645

646

647 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){

648 b = blks;

649 size[0] = 5 * 6 * 4; //EOB

650 for (j = 0; j < 6 *5; j++, b++) {

651 prev = b->prev[0];

652 for (k = b->next[prev]; k < 64; k = b->next[k]) {

653 if (b->mb[k] < a && b->mb[k] > -a){

654 b->next[prev] = b->next[k];

655 }else{

656 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);

657 prev = k;

658 }

659 }

660 }

661 }

662 }

663

664 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)

665 {

666 DVVideoContext *s = avctx->priv_data;

667 DVwork_chunk *work_chunk = arg;

668 int mb_index, i, j;

669 int mb_x, mb_y, c_offset, linesize, y_stride;

670 uint8_t* y_ptr;

671 uint8_t* dif;

672 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);

673 EncBlockInfo enc_blks[5*DV_MAX_BPM];

674 PutBitContext pbs[5*DV_MAX_BPM];

675 PutBitContext* pb;

676 EncBlockInfo* enc_blk;

677 int vs_bit_size = 0;

678 int qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */

679 int* qnosp = &qnos[0];

680

681 dif = &s->buf[work_chunk->buf_offset*80];

682 enc_blk = &enc_blks[0];

683 for (mb_index = 0; mb_index < 5; mb_index++) {

684 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);

685

686 /* initializing luminance blocks */

687 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||

688 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||

689 (s->sys->height >= 720 && mb_y != 134)) {

690 y_stride = s->picture.linesize[0] << 3;

691 } else {

692 y_stride = 16;

693 }

694 y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);

695 linesize = s->picture.linesize[0];

696

697 if (s->sys->video_stype == 4) { /* SD 422 */

698 vs_bit_size +=

699 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +

700 dv_init_enc_block(enc_blk+1, NULL , linesize, s, 0) +

701 dv_init_enc_block(enc_blk+2, y_ptr + 8 , linesize, s, 0) +

702 dv_init_enc_block(enc_blk+3, NULL , linesize, s, 0);

703 } else {

704 vs_bit_size +=

705 dv_init_enc_block(enc_blk+0, y_ptr , linesize, s, 0) +

706 dv_init_enc_block(enc_blk+1, y_ptr + 8 , linesize, s, 0) +

707 dv_init_enc_block(enc_blk+2, y_ptr + y_stride, linesize, s, 0) +

708 dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);

709 }

710 enc_blk += 4;

711

712 /* initializing chrominance blocks */

713 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->picture.linesize[1] +

714 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);

715 for (j = 2; j; j--) {

716 uint8_t *c_ptr = s->picture.data[j] + c_offset;

717 linesize = s->picture.linesize[j];

718 y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);

719 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {

720 uint8_t* d;

721 uint8_t* b = scratch;

722 for (i = 0; i < 8; i++) {

723 d = c_ptr + (linesize << 3);

724 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];

725 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];

726 c_ptr += linesize;

727 b += 16;

728 }

729 c_ptr = scratch;

730 linesize = 16;

731 }

732

733 vs_bit_size += dv_init_enc_block( enc_blk++, c_ptr , linesize, s, 1);

734 if (s->sys->bpm == 8) {

735 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);

736 }

737 }

738 }

739

740 if (vs_total_ac_bits < vs_bit_size)

741 dv_guess_qnos(&enc_blks[0], qnosp);

742

743 /* DIF encoding process */

744 for (j=0; j<5*s->sys->bpm;) {

745 int start_mb = j;

746

747 dif[3] = *qnosp++;

748 dif += 4;

749

750 /* First pass over individual cells only */

751 for (i=0; i<s->sys->bpm; i++, j++) {

752 int sz = s->sys->block_sizes[i]>>3;

753

754 init_put_bits(&pbs[j], dif, sz);

755 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);

756 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);

757 put_bits(&pbs[j], 2, enc_blks[j].cno);

758

759 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);

760 dif += sz;

761 }

762

763 /* Second pass over each MB space */

764 pb = &pbs[start_mb];

765 for (i=0; i<s->sys->bpm; i++) {

766 if (enc_blks[start_mb+i].partial_bit_count)

767 pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);

768 }

769 }

770

771 /* Third and final pass over the whole video segment space */

772 pb = &pbs[0];

773 for (j=0; j<5*s->sys->bpm; j++) {

774 if (enc_blks[j].partial_bit_count)

775 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);

776 if (enc_blks[j].partial_bit_count)

777 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");

778 }

779

780 for (j=0; j<5*s->sys->bpm; j++) {

781 int pos;

782 int size = pbs[j].size_in_bits >> 3;

783 flush_put_bits(&pbs[j]);

784 pos = put_bits_count(&pbs[j]) >> 3;

785 if (pos > size) {

786 av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");

787 return -1;

788 }

789 memset(pbs[j].buf + pos, 0xff, size - pos);

790 }

791

792 return 0;

793 }

794

795 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,

796 uint8_t* buf)

797 {

798 /*

799 * Here's what SMPTE314M says about these two:

800 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical

801 * as track application IDs (APTn = 001, AP1n =

802 * 001, AP2n = 001, AP3n = 001), if the source signal

803 * comes from a digital VCR. If the signal source is

804 * unknown, all bits for these data shall be set to 1.

805 * (page 12) STYPE: STYPE defines a signal type of video signal

806 * 00000b = 4:1:1 compression

807 * 00100b = 4:2:2 compression

808 * XXXXXX = Reserved

809 * Now, I've got two problems with these statements:

810 * 1. it looks like APT == 111b should be a safe bet, but it isn't.

811 * It seems that for PAL as defined in IEC 61834 we have to set

812 * APT to 000 and for SMPTE314M to 001.

813 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL

814 * compression scheme (if any).

815 */

816 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);

817 int fs = c->picture.top_field_first ? 0x00 : 0x40;

818

819 uint8_t aspect = 0;

820 if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */

821 aspect = 0x02;

822

823 buf[0] = (uint8_t)pack_id;

824 switch (pack_id) {

825 case dv_header525: /* I can't imagine why these two weren't defined as real */

826 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */

827 buf[1] = 0xf8 | /* reserved -- always 1 */

828 (apt & 0x07); /* APT: Track application ID */

829 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */

830 (0x0f << 3) | /* reserved -- always 1 */

831 (apt & 0x07); /* AP1: Audio application ID */

832 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */

833 (0x0f << 3) | /* reserved -- always 1 */

834 (apt & 0x07); /* AP2: Video application ID */

835 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */

836 (0x0f << 3) | /* reserved -- always 1 */

837 (apt & 0x07); /* AP3: Subcode application ID */

838 break;

839 case dv_video_source:

840 buf[1] = 0xff; /* reserved -- always 1 */

841 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */

842 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */

843 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */

844 0xf; /* reserved -- always 1 */

845 buf[3] = (3 << 6) | /* reserved -- always 1 */

846 (c->sys->dsf << 5) | /* system: 60fields/50fields */

847 c->sys->video_stype; /* signal type video compression */

848 buf[4] = 0xff; /* VISC: 0xff -- no information */

849 break;

850 case dv_video_control:

851 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */

852 0x3f; /* reserved -- always 1 */

853 buf[2] = 0xc8 | /* reserved -- always b11001xxx */

854 aspect;

855 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */

856 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */

857 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */

858 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */

859 0xc; /* reserved -- always b1100 */

860 buf[4] = 0xff; /* reserved -- always 1 */

861 break;

862 default:

863 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;

864 }

865 return 5;

866 }

867

868 #if CONFIG_DVVIDEO_ENCODER

869 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,

870 uint8_t seq_num, uint8_t dif_num,

871 uint8_t* buf)

872 {

873 buf[0] = (uint8_t)t; /* Section type */

874 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */

875 (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */

876 7; /* reserved -- always 1 */

877 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */

878 return 3;

879 }

880

881

882 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t* buf)

883 {

884 if (syb_num == 0 || syb_num == 6) {

885 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */

886 (0 << 4) | /* AP3 (Subcode application ID) */

887 0x0f; /* reserved -- always 1 */

888 }

889 else if (syb_num == 11) {

890 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */

891 0x7f; /* reserved -- always 1 */

892 }

893 else {

894 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */

895 (0 << 4) | /* APT (Track application ID) */

896 0x0f; /* reserved -- always 1 */

897 }

898 buf[1] = 0xf0 | /* reserved -- always 1 */

899 (syb_num & 0x0f); /* SSYB number 0 - 11 */

900 buf[2] = 0xff; /* reserved -- always 1 */

901 return 3;

902 }

903

904 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)

905 {

906 int chan, i, j, k;

907

908 for (chan = 0; chan < c->sys->n_difchan; chan++) {

909 for (i = 0; i < c->sys->difseg_size; i++) {

910 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */

911

912 /* DV header: 1DIF */

913 buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);

914 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);

915 buf += 72; /* unused bytes */

916

917 /* DV subcode: 2DIFs */

918 for (j = 0; j < 2; j++) {

919 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);

920 for (k = 0; k < 6; k++)

921 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;

922 buf += 29; /* unused bytes */

923 }

924

925 /* DV VAUX: 3DIFS */

926 for (j = 0; j < 3; j++) {

927 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);

928 buf += dv_write_pack(dv_video_source, c, buf);

929 buf += dv_write_pack(dv_video_control, c, buf);

930 buf += 7*5;

931 buf += dv_write_pack(dv_video_source, c, buf);

932 buf += dv_write_pack(dv_video_control, c, buf);

933 buf += 4*5 + 2; /* unused bytes */

934 }

935

936 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */

937 for (j = 0; j < 135; j++) {

938 if (j%15 == 0) {

939 memset(buf, 0xff, 80);

940 buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);

941 buf += 77; /* audio control & shuffled PCM audio */

942 }

943 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);

944 buf += 77; /* 1 video macroblock: 1 bytes control

945 4 * 14 bytes Y 8x8 data

946 10 bytes Cr 8x8 data

947 10 bytes Cb 8x8 data */

948 }

949 }

950 }

951 }

952

953

954 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,

955 const AVFrame *frame, int *got_packet)

956 {

957 DVVideoContext *s = c->priv_data;

958 int ret;

959

960 s->sys = avpriv_dv_codec_profile(c);

961 if (!s->sys || ff_dv_init_dynamic_tables(s->sys))

962 return -1;

963 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)

964 return ret;

965

966 c->pix_fmt = s->sys->pix_fmt;

967 s->picture = *frame;

968 s->picture.key_frame = 1;

969 s->picture.pict_type = AV_PICTURE_TYPE_I;

970

971 s->buf = pkt->data;

972 c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,

973 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));

974

975 emms_c();

976

977 dv_format_frame(s, pkt->data);

978

979 pkt->flags |= AV_PKT_FLAG_KEY;

980 *got_packet = 1;

981

982 return 0;

983 }

984

985 AVCodec ff_dvvideo_encoder = {

986 .name = "dvvideo",

987 .type = AVMEDIA_TYPE_VIDEO,

988 .id = AV_CODEC_ID_DVVIDEO,

989 .priv_data_size = sizeof(DVVideoContext),

990 .init = dvvideo_init_encoder,

991 .encode2 = dvvideo_encode_frame,

992 .capabilities = CODEC_CAP_SLICE_THREADS,

993 .pix_fmts = (const enum AVPixelFormat[]) {

994 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE

995 },

996 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),

997 };

998 #endif // CONFIG_DVVIDEO_ENCODER

Generated on Wed Jul 10 2013 23:47:57 for FFmpeg by doxygen 1.8.2