FFmpeg: libavcodec/dvbsubdec.c Source File

FFmpeg

[フレーム]

libavcodec

dvbsubdec.c

Go to the documentation of this file.

1 /*

2 * DVB subtitle decoding

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 #include "avcodec.h"

23 #include "get_bits.h"

24 #include "bytestream.h"

25 #include "libavutil/colorspace.h"

26 #include "libavutil/opt.h"

28 #define DVBSUB_PAGE_SEGMENT 0x10

29 #define DVBSUB_REGION_SEGMENT 0x11

30 #define DVBSUB_CLUT_SEGMENT 0x12

31 #define DVBSUB_OBJECT_SEGMENT 0x13

32 #define DVBSUB_DISPLAYDEFINITION_SEGMENT 0x14

33 #define DVBSUB_DISPLAY_SEGMENT 0x80

35 #define cm (ff_crop_tab + MAX_NEG_CROP)

37 #ifdef DEBUG

38 #if 0

39 static void png_save(const char *filename, uint8_t *bitmap, int w, int h,

40 uint32_t *rgba_palette)

41 {

42 int x, y, v;

43 FILE *f;

44 char fname[40], fname2[40];

45 char command[1024];

47 snprintf(fname, 40, "%s.ppm", filename);

49 f = fopen(fname, "w");

50 if (!f) {

51 perror(fname);

52 return;

53 }

54 fprintf(f, "P6\n"

55 "%d %d\n"

56 "%d\n",

57 w, h, 255);

58 for(y = 0; y < h; y++) {

59 for(x = 0; x < w; x++) {

60 v = rgba_palette[bitmap[y * w + x]];

61 putc((v >> 16) & 0xff, f);

62 putc((v >> 8) & 0xff, f);

63 putc((v >> 0) & 0xff, f);

64 }

65 }

66 fclose(f);

69 snprintf(fname2, 40, "%s-a.pgm", filename);

71 f = fopen(fname2, "w");

72 if (!f) {

73 perror(fname2);

74 return;

75 }

76 fprintf(f, "P5\n"

77 "%d %d\n"

78 "%d\n",

79 w, h, 255);

80 for(y = 0; y < h; y++) {

81 for(x = 0; x < w; x++) {

82 v = rgba_palette[bitmap[y * w + x]];

83 putc((v >> 24) & 0xff, f);

84 }

85 }

86 fclose(f);

88 snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);

89 system(command);

91 snprintf(command, 1024, "rm %s %s", fname, fname2);

92 system(command);

93 }

94 #endif

96 static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)

97 {

98 int x, y, v;

99 FILE *f;

100 char fname[40], fname2[40];

101 char command[1024];

102

103 snprintf(fname, sizeof(fname), "%s.ppm", filename);

104

105 f = fopen(fname, "w");

106 if (!f) {

107 perror(fname);

108 return;

109 }

110 fprintf(f, "P6\n"

111 "%d %d\n"

112 "%d\n",

113 w, h, 255);

114 for(y = 0; y < h; y++) {

115 for(x = 0; x < w; x++) {

116 v = bitmap[y * w + x];

117 putc((v >> 16) & 0xff, f);

118 putc((v >> 8) & 0xff, f);

119 putc((v >> 0) & 0xff, f);

120 }

121 }

122 fclose(f);

123

124

125 snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);

126

127 f = fopen(fname2, "w");

128 if (!f) {

129 perror(fname2);

130 return;

131 }

132 fprintf(f, "P5\n"

133 "%d %d\n"

134 "%d\n",

135 w, h, 255);

136 for(y = 0; y < h; y++) {

137 for(x = 0; x < w; x++) {

138 v = bitmap[y * w + x];

139 putc((v >> 24) & 0xff, f);

140 }

141 }

142 fclose(f);

143

144 snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);

145 system(command);

146

147 snprintf(command, sizeof(command), "rm %s %s", fname, fname2);

148 system(command);

149 }

150 #endif

151

152 #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))

153

154 typedef struct DVBSubCLUT {

155 int id;

156 int version;

157

158 uint32_t clut4[4];

159 uint32_t clut16[16];

160 uint32_t clut256[256];

161

162 struct DVBSubCLUT *next;

163 } DVBSubCLUT;

164

165 static DVBSubCLUT default_clut;

166

167 typedef struct DVBSubObjectDisplay {

168 int object_id;

169 int region_id;

170

171 int x_pos;

172 int y_pos;

173

174 int fgcolor;

175 int bgcolor;

176

177 struct DVBSubObjectDisplay *region_list_next;

178 struct DVBSubObjectDisplay *object_list_next;

179 } DVBSubObjectDisplay;

180

181 typedef struct DVBSubObject {

182 int id;

183 int version;

184

185 int type;

186

187 DVBSubObjectDisplay *display_list;

188

189 struct DVBSubObject *next;

190 } DVBSubObject;

191

192 typedef struct DVBSubRegionDisplay {

193 int region_id;

194

195 int x_pos;

196 int y_pos;

197

198 struct DVBSubRegionDisplay *next;

199 } DVBSubRegionDisplay;

200

201 typedef struct DVBSubRegion {

202 int id;

203 int version;

204

205 int width;

206 int height;

207 int depth;

208

209 int clut;

210 int bgcolor;

211

212 uint8_t *pbuf;

213 int buf_size;

214 int dirty;

215

216 DVBSubObjectDisplay *display_list;

217

218 struct DVBSubRegion *next;

219 } DVBSubRegion;

220

221 typedef struct DVBSubDisplayDefinition {

222 int version;

223

224 int x;

225 int y;

226 int width;

227 int height;

228 } DVBSubDisplayDefinition;

229

230 typedef struct DVBSubContext {

231 AVClass *class;

232 int composition_id;

233 int ancillary_id;

234

235 int version;

236 int time_out;

237 int compute_edt; /**< if 1 end display time calculated using pts

238 if 0 (Default) calculated using time out */

239 int64_t prev_start;

240 DVBSubRegion *region_list;

241 DVBSubCLUT *clut_list;

242 DVBSubObject *object_list;

243

244 DVBSubRegionDisplay *display_list;

245 DVBSubDisplayDefinition *display_definition;

246 } DVBSubContext;

247

248

249 static DVBSubObject* get_object(DVBSubContext *ctx, int object_id)

250 {

251 DVBSubObject *ptr = ctx->object_list;

252

253 while (ptr && ptr->id != object_id) {

254 ptr = ptr->next;

255 }

256

257 return ptr;

258 }

259

260 static DVBSubCLUT* get_clut(DVBSubContext *ctx, int clut_id)

261 {

262 DVBSubCLUT *ptr = ctx->clut_list;

263

264 while (ptr && ptr->id != clut_id) {

265 ptr = ptr->next;

266 }

267

268 return ptr;

269 }

270

271 static DVBSubRegion* get_region(DVBSubContext *ctx, int region_id)

272 {

273 DVBSubRegion *ptr = ctx->region_list;

274

275 while (ptr && ptr->id != region_id) {

276 ptr = ptr->next;

277 }

278

279 return ptr;

280 }

281

282 static void delete_region_display_list(DVBSubContext *ctx, DVBSubRegion *region)

283 {

284 DVBSubObject *object, *obj2, **obj2_ptr;

285 DVBSubObjectDisplay *display, *obj_disp, **obj_disp_ptr;

286

287 while (region->display_list) {

288 display = region->display_list;

289

290 object = get_object(ctx, display->object_id);

291

292 if (object) {

293 obj_disp_ptr = &object->display_list;

294 obj_disp = *obj_disp_ptr;

295

296 while (obj_disp && obj_disp != display) {

297 obj_disp_ptr = &obj_disp->object_list_next;

298 obj_disp = *obj_disp_ptr;

299 }

300

301 if (obj_disp) {

302 *obj_disp_ptr = obj_disp->object_list_next;

303

304 if (!object->display_list) {

305 obj2_ptr = &ctx->object_list;

306 obj2 = *obj2_ptr;

307

308 while (obj2 != object) {

309 assert(obj2);

310 obj2_ptr = &obj2->next;

311 obj2 = *obj2_ptr;

312 }

313

314 *obj2_ptr = obj2->next;

315

316 av_free(obj2);

317 }

318 }

319 }

320

321 region->display_list = display->region_list_next;

322

323 av_free(display);

324 }

325

326 }

327

328 static void delete_cluts(DVBSubContext *ctx)

329 {

330 DVBSubCLUT *clut;

331

332 while (ctx->clut_list) {

333 clut = ctx->clut_list;

334

335 ctx->clut_list = clut->next;

336

337 av_free(clut);

338 }

339 }

340

341 static void delete_objects(DVBSubContext *ctx)

342 {

343 DVBSubObject *object;

344

345 while (ctx->object_list) {

346 object = ctx->object_list;

347

348 ctx->object_list = object->next;

349

350 av_free(object);

351 }

352 }

353

354 static void delete_regions(DVBSubContext *ctx)

355 {

356 DVBSubRegion *region;

357

358 while (ctx->region_list) {

359 region = ctx->region_list;

360

361 ctx->region_list = region->next;

362

363 delete_region_display_list(ctx, region);

364

365 av_free(region->pbuf);

366 av_free(region);

367 }

368 }

369

370 static av_cold int dvbsub_init_decoder(AVCodecContext *avctx)

371 {

372 int i, r, g, b, a = 0;

373 DVBSubContext *ctx = avctx->priv_data;

374

375 if (!avctx->extradata || (avctx->extradata_size < 4) || ((avctx->extradata_size % 5 != 0) && (avctx->extradata_size != 4))) {

376 av_log(avctx, AV_LOG_WARNING, "Invalid DVB subtitles stream extradata!\n");

377 ctx->composition_id = -1;

378 ctx->ancillary_id = -1;

379 } else {

380 if (avctx->extradata_size > 5) {

381 av_log(avctx, AV_LOG_WARNING, "Decoding first DVB subtitles sub-stream\n");

382 }

383

384 ctx->composition_id = AV_RB16(avctx->extradata);

385 ctx->ancillary_id = AV_RB16(avctx->extradata + 2);

386 }

387

388 ctx->version = -1;

389 ctx->prev_start = AV_NOPTS_VALUE;

390

391 default_clut.id = -1;

392 default_clut.next = NULL;

393

394 default_clut.clut4[0] = RGBA( 0, 0, 0, 0);

395 default_clut.clut4[1] = RGBA(255, 255, 255, 255);

396 default_clut.clut4[2] = RGBA( 0, 0, 0, 255);

397 default_clut.clut4[3] = RGBA(127, 127, 127, 255);

398

399 default_clut.clut16[0] = RGBA( 0, 0, 0, 0);

400 for (i = 1; i < 16; i++) {

401 if (i < 8) {

402 r = (i & 1) ? 255 : 0;

403 g = (i & 2) ? 255 : 0;

404 b = (i & 4) ? 255 : 0;

405 } else {

406 r = (i & 1) ? 127 : 0;

407 g = (i & 2) ? 127 : 0;

408 b = (i & 4) ? 127 : 0;

409 }

410 default_clut.clut16[i] = RGBA(r, g, b, 255);

411 }

412

413 default_clut.clut256[0] = RGBA( 0, 0, 0, 0);

414 for (i = 1; i < 256; i++) {

415 if (i < 8) {

416 r = (i & 1) ? 255 : 0;

417 g = (i & 2) ? 255 : 0;

418 b = (i & 4) ? 255 : 0;

419 a = 63;

420 } else {

421 switch (i & 0x88) {

422 case 0x00:

423 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);

424 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);

425 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);

426 a = 255;

427 break;

428 case 0x08:

429 r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);

430 g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);

431 b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);

432 a = 127;

433 break;

434 case 0x80:

435 r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);

436 g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);

437 b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);

438 a = 255;

439 break;

440 case 0x88:

441 r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);

442 g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);

443 b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);

444 a = 255;

445 break;

446 }

447 }

448 default_clut.clut256[i] = RGBA(r, g, b, a);

449 }

450

451 return 0;

452 }

453

454 static av_cold int dvbsub_close_decoder(AVCodecContext *avctx)

455 {

456 DVBSubContext *ctx = avctx->priv_data;

457 DVBSubRegionDisplay *display;

458

459 delete_regions(ctx);

460

461 delete_objects(ctx);

462

463 delete_cluts(ctx);

464

465 av_freep(&ctx->display_definition);

466

467 while (ctx->display_list) {

468 display = ctx->display_list;

469 ctx->display_list = display->next;

470

471 av_free(display);

472 }

473

474 return 0;

475 }

476

477 static int dvbsub_read_2bit_string(uint8_t *destbuf, int dbuf_len,

478 const uint8_t **srcbuf, int buf_size,

479 int non_mod, uint8_t *map_table, int x_pos)

480 {

481 GetBitContext gb;

482

483 int bits;

484 int run_length;

485 int pixels_read = x_pos;

486

487 init_get_bits(&gb, *srcbuf, buf_size << 3);

488

489 destbuf += x_pos;

490

491 while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {

492 bits = get_bits(&gb, 2);

493

494 if (bits) {

495 if (non_mod != 1 || bits != 1) {

496 if (map_table)

497 *destbuf++ = map_table[bits];

498 else

499 *destbuf++ = bits;

500 }

501 pixels_read++;

502 } else {

503 bits = get_bits1(&gb);

504 if (bits == 1) {

505 run_length = get_bits(&gb, 3) + 3;

506 bits = get_bits(&gb, 2);

507

508 if (non_mod == 1 && bits == 1)

509 pixels_read += run_length;

510 else {

511 if (map_table)

512 bits = map_table[bits];

513 while (run_length-- > 0 && pixels_read < dbuf_len) {

514 *destbuf++ = bits;

515 pixels_read++;

516 }

517 }

518 } else {

519 bits = get_bits1(&gb);

520 if (bits == 0) {

521 bits = get_bits(&gb, 2);

522 if (bits == 2) {

523 run_length = get_bits(&gb, 4) + 12;

524 bits = get_bits(&gb, 2);

525

526 if (non_mod == 1 && bits == 1)

527 pixels_read += run_length;

528 else {

529 if (map_table)

530 bits = map_table[bits];

531 while (run_length-- > 0 && pixels_read < dbuf_len) {

532 *destbuf++ = bits;

533 pixels_read++;

534 }

535 }

536 } else if (bits == 3) {

537 run_length = get_bits(&gb, 8) + 29;

538 bits = get_bits(&gb, 2);

539

540 if (non_mod == 1 && bits == 1)

541 pixels_read += run_length;

542 else {

543 if (map_table)

544 bits = map_table[bits];

545 while (run_length-- > 0 && pixels_read < dbuf_len) {

546 *destbuf++ = bits;

547 pixels_read++;

548 }

549 }

550 } else if (bits == 1) {

551 if (map_table)

552 bits = map_table[0];

553 else

554 bits = 0;

555 run_length = 2;

556 while (run_length-- > 0 && pixels_read < dbuf_len) {

557 *destbuf++ = bits;

558 pixels_read++;

559 }

560 } else {

561 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

562 return pixels_read;

563 }

564 } else {

565 if (map_table)

566 bits = map_table[0];

567 else

568 bits = 0;

569 *destbuf++ = bits;

570 pixels_read++;

571 }

572 }

573 }

574 }

575

576 if (get_bits(&gb, 6))

577 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");

578

579 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

580

581 return pixels_read;

582 }

583

584 static int dvbsub_read_4bit_string(uint8_t *destbuf, int dbuf_len,

585 const uint8_t **srcbuf, int buf_size,

586 int non_mod, uint8_t *map_table, int x_pos)

587 {

588 GetBitContext gb;

589

590 int bits;

591 int run_length;

592 int pixels_read = x_pos;

593

594 init_get_bits(&gb, *srcbuf, buf_size << 3);

595

596 destbuf += x_pos;

597

598 while (get_bits_count(&gb) < buf_size << 3 && pixels_read < dbuf_len) {

599 bits = get_bits(&gb, 4);

600

601 if (bits) {

602 if (non_mod != 1 || bits != 1) {

603 if (map_table)

604 *destbuf++ = map_table[bits];

605 else

606 *destbuf++ = bits;

607 }

608 pixels_read++;

609 } else {

610 bits = get_bits1(&gb);

611 if (bits == 0) {

612 run_length = get_bits(&gb, 3);

613

614 if (run_length == 0) {

615 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

616 return pixels_read;

617 }

618

619 run_length += 2;

620

621 if (map_table)

622 bits = map_table[0];

623 else

624 bits = 0;

625

626 while (run_length-- > 0 && pixels_read < dbuf_len) {

627 *destbuf++ = bits;

628 pixels_read++;

629 }

630 } else {

631 bits = get_bits1(&gb);

632 if (bits == 0) {

633 run_length = get_bits(&gb, 2) + 4;

634 bits = get_bits(&gb, 4);

635

636 if (non_mod == 1 && bits == 1)

637 pixels_read += run_length;

638 else {

639 if (map_table)

640 bits = map_table[bits];

641 while (run_length-- > 0 && pixels_read < dbuf_len) {

642 *destbuf++ = bits;

643 pixels_read++;

644 }

645 }

646 } else {

647 bits = get_bits(&gb, 2);

648 if (bits == 2) {

649 run_length = get_bits(&gb, 4) + 9;

650 bits = get_bits(&gb, 4);

651

652 if (non_mod == 1 && bits == 1)

653 pixels_read += run_length;

654 else {

655 if (map_table)

656 bits = map_table[bits];

657 while (run_length-- > 0 && pixels_read < dbuf_len) {

658 *destbuf++ = bits;

659 pixels_read++;

660 }

661 }

662 } else if (bits == 3) {

663 run_length = get_bits(&gb, 8) + 25;

664 bits = get_bits(&gb, 4);

665

666 if (non_mod == 1 && bits == 1)

667 pixels_read += run_length;

668 else {

669 if (map_table)

670 bits = map_table[bits];

671 while (run_length-- > 0 && pixels_read < dbuf_len) {

672 *destbuf++ = bits;

673 pixels_read++;

674 }

675 }

676 } else if (bits == 1) {

677 if (map_table)

678 bits = map_table[0];

679 else

680 bits = 0;

681 run_length = 2;

682 while (run_length-- > 0 && pixels_read < dbuf_len) {

683 *destbuf++ = bits;

684 pixels_read++;

685 }

686 } else {

687 if (map_table)

688 bits = map_table[0];

689 else

690 bits = 0;

691 *destbuf++ = bits;

692 pixels_read ++;

693 }

694 }

695 }

696 }

697 }

698

699 if (get_bits(&gb, 8))

700 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");

701

702 (*srcbuf) += (get_bits_count(&gb) + 7) >> 3;

703

704 return pixels_read;

705 }

706

707 static int dvbsub_read_8bit_string(uint8_t *destbuf, int dbuf_len,

708 const uint8_t **srcbuf, int buf_size,

709 int non_mod, uint8_t *map_table, int x_pos)

710 {

711 const uint8_t *sbuf_end = (*srcbuf) + buf_size;

712 int bits;

713 int run_length;

714 int pixels_read = x_pos;

715

716 destbuf += x_pos;

717

718 while (*srcbuf < sbuf_end && pixels_read < dbuf_len) {

719 bits = *(*srcbuf)++;

720

721 if (bits) {

722 if (non_mod != 1 || bits != 1) {

723 if (map_table)

724 *destbuf++ = map_table[bits];

725 else

726 *destbuf++ = bits;

727 }

728 pixels_read++;

729 } else {

730 bits = *(*srcbuf)++;

731 run_length = bits & 0x7f;

732 if ((bits & 0x80) == 0) {

733 if (run_length == 0) {

734 return pixels_read;

735 }

736

737 if (map_table)

738 bits = map_table[0];

739 else

740 bits = 0;

741 while (run_length-- > 0 && pixels_read < dbuf_len) {

742 *destbuf++ = bits;

743 pixels_read++;

744 }

745 } else {

746 bits = *(*srcbuf)++;

747

748 if (non_mod == 1 && bits == 1)

749 pixels_read += run_length;

750 if (map_table)

751 bits = map_table[bits];

752 else while (run_length-- > 0 && pixels_read < dbuf_len) {

753 *destbuf++ = bits;

754 pixels_read++;

755 }

756 }

757 }

758 }

759

760 if (*(*srcbuf)++)

761 av_log(0, AV_LOG_ERROR, "DVBSub error: line overflow\n");

762

763 return pixels_read;

764 }

765

766 static void save_subtitle_set(AVCodecContext *avctx, AVSubtitle *sub, int *got_output)

767 {

768 DVBSubContext *ctx = avctx->priv_data;

769 DVBSubRegionDisplay *display;

770 DVBSubDisplayDefinition *display_def = ctx->display_definition;

771 DVBSubRegion *region;

772 AVSubtitleRect *rect;

773 DVBSubCLUT *clut;

774 uint32_t *clut_table;

775 int i;

776 int offset_x=0, offset_y=0;

777

778

779 if (display_def) {

780 offset_x = display_def->x;

781 offset_y = display_def->y;

782 }

783

784 /* Not touching AVSubtitles again*/

785 if(sub->num_rects) {

786 avpriv_request_sample(ctx, "Different Version of Segment asked Twice\n");

787 return;

788 }

789 for (display = ctx->display_list; display; display = display->next) {

790 region = get_region(ctx, display->region_id);

791 if (region && region->dirty)

792 sub->num_rects++;

793 }

794

795 if(ctx->compute_edt == 0) {

796 sub->end_display_time = ctx->time_out * 1000;

797 *got_output = 1;

798 } else if (ctx->prev_start != AV_NOPTS_VALUE) {

799 sub->end_display_time = av_rescale_q((sub->pts - ctx->prev_start ), AV_TIME_BASE_Q, (AVRational){ 1, 1000 }) - 1;

800 *got_output = 1;

801 }

802 if (sub->num_rects > 0) {

803

804 sub->rects = av_mallocz_array(sizeof(*sub->rects), sub->num_rects);

805 for(i=0; i<sub->num_rects; i++)

806 sub->rects[i] = av_mallocz(sizeof(*sub->rects[i]));

807

808 i = 0;

809

810 for (display = ctx->display_list; display; display = display->next) {

811 region = get_region(ctx, display->region_id);

812

813 if (!region)

814 continue;

815

816 if (!region->dirty)

817 continue;

818

819 rect = sub->rects[i];

820 rect->x = display->x_pos + offset_x;

821 rect->y = display->y_pos + offset_y;

822 rect->w = region->width;

823 rect->h = region->height;

824 rect->nb_colors = (1 << region->depth);

825 rect->type = SUBTITLE_BITMAP;

826 rect->pict.linesize[0] = region->width;

827

828 clut = get_clut(ctx, region->clut);

829

830 if (!clut)

831 clut = &default_clut;

832

833 switch (region->depth) {

834 case 2:

835 clut_table = clut->clut4;

836 break;

837 case 8:

838 clut_table = clut->clut256;

839 break;

840 case 4:

841 default:

842 clut_table = clut->clut16;

843 break;

844 }

845

846 rect->pict.data[1] = av_mallocz(AVPALETTE_SIZE);

847 memcpy(rect->pict.data[1], clut_table, (1 << region->depth) * sizeof(uint32_t));

848

849 rect->pict.data[0] = av_malloc(region->buf_size);

850 memcpy(rect->pict.data[0], region->pbuf, region->buf_size);

851

852 i++;

853 }

854 }

855 }

856

857 static void dvbsub_parse_pixel_data_block(AVCodecContext *avctx, DVBSubObjectDisplay *display,

858 const uint8_t *buf, int buf_size, int top_bottom, int non_mod)

859 {

860 DVBSubContext *ctx = avctx->priv_data;

861

862 DVBSubRegion *region = get_region(ctx, display->region_id);

863 const uint8_t *buf_end = buf + buf_size;

864 uint8_t *pbuf;

865 int x_pos, y_pos;

866 int i;

867

868 uint8_t map2to4[] = { 0x0, 0x7, 0x8, 0xf};

869 uint8_t map2to8[] = {0x00, 0x77, 0x88, 0xff};

870 uint8_t map4to8[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,

871 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};

872 uint8_t *map_table;

873

874 #if 0

875 av_dlog(avctx, "DVB pixel block size %d, %s field:\n", buf_size,

876 top_bottom ? "bottom" : "top");

877

878 for (i = 0; i < buf_size; i++) {

879 if (i % 16 == 0)

880 av_dlog(avctx, "0x%8p: ", buf+i);

881

882 av_dlog(avctx, "%02x ", buf[i]);

883 if (i % 16 == 15)

884 av_dlog(avctx, "\n");

885 }

886

887 if (i % 16)

888 av_dlog(avctx, "\n");

889 #endif

890

891 if (region == 0)

892 return;

893

894 pbuf = region->pbuf;

895 region->dirty = 1;

896

897 x_pos = display->x_pos;

898 y_pos = display->y_pos;

899

900 y_pos += top_bottom;

901

902 while (buf < buf_end) {

903 if ((*buf!=0xf0 && x_pos >= region->width) || y_pos >= region->height) {

904 av_log(avctx, AV_LOG_ERROR, "Invalid object location! %d-%d %d-%d %02x\n", x_pos, region->width, y_pos, region->height, *buf);

905 return;

906 }

907

908 switch (*buf++) {

909 case 0x10:

910 if (region->depth == 8)

911 map_table = map2to8;

912 else if (region->depth == 4)

913 map_table = map2to4;

914 else

915 map_table = NULL;

916

917 x_pos = dvbsub_read_2bit_string(pbuf + (y_pos * region->width),

918 region->width, &buf, buf_end - buf,

919 non_mod, map_table, x_pos);

920 break;

921 case 0x11:

922 if (region->depth < 4) {

923 av_log(avctx, AV_LOG_ERROR, "4-bit pixel string in %d-bit region!\n", region->depth);

924 return;

925 }

926

927 if (region->depth == 8)

928 map_table = map4to8;

929 else

930 map_table = NULL;

931

932 x_pos = dvbsub_read_4bit_string(pbuf + (y_pos * region->width),

933 region->width, &buf, buf_end - buf,

934 non_mod, map_table, x_pos);

935 break;

936 case 0x12:

937 if (region->depth < 8) {

938 av_log(avctx, AV_LOG_ERROR, "8-bit pixel string in %d-bit region!\n", region->depth);

939 return;

940 }

941

942 x_pos = dvbsub_read_8bit_string(pbuf + (y_pos * region->width),

943 region->width, &buf, buf_end - buf,

944 non_mod, NULL, x_pos);

945 break;

946

947 case 0x20:

948 map2to4[0] = (*buf) >> 4;

949 map2to4[1] = (*buf++) & 0xf;

950 map2to4[2] = (*buf) >> 4;

951 map2to4[3] = (*buf++) & 0xf;

952 break;

953 case 0x21:

954 for (i = 0; i < 4; i++)

955 map2to8[i] = *buf++;

956 break;

957 case 0x22:

958 for (i = 0; i < 16; i++)

959 map4to8[i] = *buf++;

960 break;

961

962 case 0xf0:

963 x_pos = display->x_pos;

964 y_pos += 2;

965 break;

966 default:

967 av_log(avctx, AV_LOG_INFO, "Unknown/unsupported pixel block 0x%x\n", *(buf-1));

968 }

969 }

970

971 }

972

973 static void dvbsub_parse_object_segment(AVCodecContext *avctx,

974 const uint8_t *buf, int buf_size)

975 {

976 DVBSubContext *ctx = avctx->priv_data;

977

978 const uint8_t *buf_end = buf + buf_size;

979 int object_id;

980 DVBSubObject *object;

981 DVBSubObjectDisplay *display;

982 int top_field_len, bottom_field_len;

983

984 int coding_method, non_modifying_color;

985

986 object_id = AV_RB16(buf);

987 buf += 2;

988

989 object = get_object(ctx, object_id);

990

991 if (!object)

992 return;

993

994 coding_method = ((*buf) >> 2) & 3;

995 non_modifying_color = ((*buf++) >> 1) & 1;

996

997 if (coding_method == 0) {

998 top_field_len = AV_RB16(buf);

999 buf += 2;

1000 bottom_field_len = AV_RB16(buf);

1001 buf += 2;

1002

1003 if (buf + top_field_len + bottom_field_len > buf_end) {

1004 av_log(avctx, AV_LOG_ERROR, "Field data size too large\n");

1005 return;

1006 }

1007

1008 for (display = object->display_list; display; display = display->object_list_next) {

1009 const uint8_t *block = buf;

1010 int bfl = bottom_field_len;

1011

1012 dvbsub_parse_pixel_data_block(avctx, display, block, top_field_len, 0,

1013 non_modifying_color);

1014

1015 if (bottom_field_len > 0)

1016 block = buf + top_field_len;

1017 else

1018 bfl = top_field_len;

1019

1020 dvbsub_parse_pixel_data_block(avctx, display, block, bfl, 1,

1021 non_modifying_color);

1022 }

1023

1024 /* } else if (coding_method == 1) {*/

1025

1026 } else {

1027 av_log(avctx, AV_LOG_ERROR, "Unknown object coding %d\n", coding_method);

1028 }

1029

1030 }

1031

1032 static int dvbsub_parse_clut_segment(AVCodecContext *avctx,

1033 const uint8_t *buf, int buf_size)

1034 {

1035 DVBSubContext *ctx = avctx->priv_data;

1036

1037 const uint8_t *buf_end = buf + buf_size;

1038 int i, clut_id;

1039 int version;

1040 DVBSubCLUT *clut;

1041 int entry_id, depth , full_range;

1042 int y, cr, cb, alpha;

1043 int r, g, b, r_add, g_add, b_add;

1044

1045 av_dlog(avctx, "DVB clut packet:\n");

1046

1047 for (i=0; i < buf_size; i++) {

1048 av_dlog(avctx, "%02x ", buf[i]);

1049 if (i % 16 == 15)

1050 av_dlog(avctx, "\n");

1051 }

1052

1053 if (i % 16)

1054 av_dlog(avctx, "\n");

1055

1056 clut_id = *buf++;

1057 version = ((*buf)>>4)&15;

1058 buf += 1;

1059

1060 clut = get_clut(ctx, clut_id);

1061

1062 if (!clut) {

1063 clut = av_malloc(sizeof(DVBSubCLUT));

1064

1065 memcpy(clut, &default_clut, sizeof(DVBSubCLUT));

1066

1067 clut->id = clut_id;

1068 clut->version = -1;

1069

1070 clut->next = ctx->clut_list;

1071 ctx->clut_list = clut;

1072 }

1073

1074 if (clut->version != version) {

1075

1076 clut->version = version;

1077

1078 while (buf + 4 < buf_end) {

1079 entry_id = *buf++;

1080

1081 depth = (*buf) & 0xe0;

1082

1083 if (depth == 0) {

1084 av_log(avctx, AV_LOG_ERROR, "Invalid clut depth 0x%x!\n", *buf);

1085 return 0;

1086 }

1087

1088 full_range = (*buf++) & 1;

1089

1090 if (full_range) {

1091 y = *buf++;

1092 cr = *buf++;

1093 cb = *buf++;

1094 alpha = *buf++;

1095 } else {

1096 y = buf[0] & 0xfc;

1097 cr = (((buf[0] & 3) << 2) | ((buf[1] >> 6) & 3)) << 4;

1098 cb = (buf[1] << 2) & 0xf0;

1099 alpha = (buf[1] << 6) & 0xc0;

1100

1101 buf += 2;

1102 }

1103

1104 if (y == 0)

1105 alpha = 0xff;

1106

1107 YUV_TO_RGB1_CCIR(cb, cr);

1108 YUV_TO_RGB2_CCIR(r, g, b, y);

1109

1110 av_dlog(avctx, "clut %d := (%d,%d,%d,%d)\n", entry_id, r, g, b, alpha);

1111 if (!!(depth & 0x80) + !!(depth & 0x40) + !!(depth & 0x20) > 1) {

1112 av_dlog(avctx, "More than one bit level marked: %x\n", depth);

1113 if (avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL)

1114 return AVERROR_INVALIDDATA;

1115 }

1116

1117 if (depth & 0x80)

1118 clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);

1119 else if (depth & 0x40)

1120 clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);

1121 else if (depth & 0x20)

1122 clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);

1123 }

1124 }

1125 return 0;

1126 }

1127

1128

1129 static void dvbsub_parse_region_segment(AVCodecContext *avctx,

1130 const uint8_t *buf, int buf_size)

1131 {

1132 DVBSubContext *ctx = avctx->priv_data;

1133

1134 const uint8_t *buf_end = buf + buf_size;

1135 int region_id, object_id;

1136 int av_unused version;

1137 DVBSubRegion *region;

1138 DVBSubObject *object;

1139 DVBSubObjectDisplay *display;

1140 int fill;

1141

1142 if (buf_size < 10)

1143 return;

1144

1145 region_id = *buf++;

1146

1147 region = get_region(ctx, region_id);

1148

1149 if (!region) {

1150 region = av_mallocz(sizeof(DVBSubRegion));

1151

1152 region->id = region_id;

1153 region->version = -1;

1154

1155 region->next = ctx->region_list;

1156 ctx->region_list = region;

1157 }

1158

1159 version = ((*buf)>>4) & 15;

1160 fill = ((*buf++) >> 3) & 1;

1161

1162 region->width = AV_RB16(buf);

1163 buf += 2;

1164 region->height = AV_RB16(buf);

1165 buf += 2;

1166

1167 if (region->width * region->height != region->buf_size) {

1168 av_free(region->pbuf);

1169

1170 region->buf_size = region->width * region->height;

1171

1172 region->pbuf = av_malloc(region->buf_size);

1173

1174 fill = 1;

1175 region->dirty = 0;

1176 }

1177

1178 region->depth = 1 << (((*buf++) >> 2) & 7);

1179 if(region->depth<2 || region->depth>8){

1180 av_log(avctx, AV_LOG_ERROR, "region depth %d is invalid\n", region->depth);

1181 region->depth= 4;

1182 }

1183 region->clut = *buf++;

1184

1185 if (region->depth == 8) {

1186 region->bgcolor = *buf++;

1187 buf += 1;

1188 } else {

1189 buf += 1;

1190

1191 if (region->depth == 4)

1192 region->bgcolor = (((*buf++) >> 4) & 15);

1193 else

1194 region->bgcolor = (((*buf++) >> 2) & 3);

1195 }

1196

1197 av_dlog(avctx, "Region %d, (%dx%d)\n", region_id, region->width, region->height);

1198

1199 if (fill) {

1200 memset(region->pbuf, region->bgcolor, region->buf_size);

1201 av_dlog(avctx, "Fill region (%d)\n", region->bgcolor);

1202 }

1203

1204 delete_region_display_list(ctx, region);

1205

1206 while (buf + 5 < buf_end) {

1207 object_id = AV_RB16(buf);

1208 buf += 2;

1209

1210 object = get_object(ctx, object_id);

1211

1212 if (!object) {

1213 object = av_mallocz(sizeof(DVBSubObject));

1214

1215 object->id = object_id;

1216 object->next = ctx->object_list;

1217 ctx->object_list = object;

1218 }

1219

1220 object->type = (*buf) >> 6;

1221

1222 display = av_mallocz(sizeof(DVBSubObjectDisplay));

1223

1224 display->object_id = object_id;

1225 display->region_id = region_id;

1226

1227 display->x_pos = AV_RB16(buf) & 0xfff;

1228 buf += 2;

1229 display->y_pos = AV_RB16(buf) & 0xfff;

1230 buf += 2;

1231

1232 if ((object->type == 1 || object->type == 2) && buf+1 < buf_end) {

1233 display->fgcolor = *buf++;

1234 display->bgcolor = *buf++;

1235 }

1236

1237 display->region_list_next = region->display_list;

1238 region->display_list = display;

1239

1240 display->object_list_next = object->display_list;

1241 object->display_list = display;

1242 }

1243 }

1244

1245 static void dvbsub_parse_page_segment(AVCodecContext *avctx,

1246 const uint8_t *buf, int buf_size, AVSubtitle *sub, int *got_output)

1247 {

1248 DVBSubContext *ctx = avctx->priv_data;

1249 DVBSubRegionDisplay *display;

1250 DVBSubRegionDisplay *tmp_display_list, **tmp_ptr;

1251

1252 const uint8_t *buf_end = buf + buf_size;

1253 int region_id;

1254 int page_state;

1255 int timeout;

1256 int version;

1257

1258 if (buf_size < 1)

1259 return;

1260

1261 timeout = *buf++;

1262 version = ((*buf)>>4) & 15;

1263 page_state = ((*buf++) >> 2) & 3;

1264

1265 if (ctx->version == version) {

1266 return;

1267 }

1268

1269 ctx->time_out = timeout;

1270 ctx->version = version;

1271

1272 av_dlog(avctx, "Page time out %ds, state %d\n", ctx->time_out, page_state);

1273

1274 if(ctx->compute_edt == 1)

1275 save_subtitle_set(avctx, sub, got_output);

1276

1277 if (page_state == 1 || page_state == 2) {

1278 delete_regions(ctx);

1279 delete_objects(ctx);

1280 delete_cluts(ctx);

1281 }

1282

1283 tmp_display_list = ctx->display_list;

1284 ctx->display_list = NULL;

1285

1286 while (buf + 5 < buf_end) {

1287 region_id = *buf++;

1288 buf += 1;

1289

1290 display = tmp_display_list;

1291 tmp_ptr = &tmp_display_list;

1292

1293 while (display && display->region_id != region_id) {

1294 tmp_ptr = &display->next;

1295 display = display->next;

1296 }

1297

1298 if (!display)

1299 display = av_mallocz(sizeof(DVBSubRegionDisplay));

1300

1301 display->region_id = region_id;

1302

1303 display->x_pos = AV_RB16(buf);

1304 buf += 2;

1305 display->y_pos = AV_RB16(buf);

1306 buf += 2;

1307

1308 *tmp_ptr = display->next;

1309

1310 display->next = ctx->display_list;

1311 ctx->display_list = display;

1312

1313 av_dlog(avctx, "Region %d, (%d,%d)\n", region_id, display->x_pos, display->y_pos);

1314 }

1315

1316 while (tmp_display_list) {

1317 display = tmp_display_list;

1318

1319 tmp_display_list = display->next;

1320

1321 av_free(display);

1322 }

1323

1324 }

1325

1326

1327 #ifdef DEBUG

1328 static void save_display_set(DVBSubContext *ctx)

1329 {

1330 DVBSubRegion *region;

1331 DVBSubRegionDisplay *display;

1332 DVBSubCLUT *clut;

1333 uint32_t *clut_table;

1334 int x_pos, y_pos, width, height;

1335 int x, y, y_off, x_off;

1336 uint32_t *pbuf;

1337 char filename[32];

1338 static int fileno_index = 0;

1339

1340 x_pos = -1;

1341 y_pos = -1;

1342 width = 0;

1343 height = 0;

1344

1345 for (display = ctx->display_list; display; display = display->next) {

1346 region = get_region(ctx, display->region_id);

1347

1348 if (x_pos == -1) {

1349 x_pos = display->x_pos;

1350 y_pos = display->y_pos;

1351 width = region->width;

1352 height = region->height;

1353 } else {

1354 if (display->x_pos < x_pos) {

1355 width += (x_pos - display->x_pos);

1356 x_pos = display->x_pos;

1357 }

1358

1359 if (display->y_pos < y_pos) {

1360 height += (y_pos - display->y_pos);

1361 y_pos = display->y_pos;

1362 }

1363

1364 if (display->x_pos + region->width > x_pos + width) {

1365 width = display->x_pos + region->width - x_pos;

1366 }

1367

1368 if (display->y_pos + region->height > y_pos + height) {

1369 height = display->y_pos + region->height - y_pos;

1370 }

1371 }

1372 }

1373

1374 if (x_pos >= 0) {

1375

1376 pbuf = av_malloc(width * height * 4);

1377

1378 for (display = ctx->display_list; display; display = display->next) {

1379 region = get_region(ctx, display->region_id);

1380

1381 x_off = display->x_pos - x_pos;

1382 y_off = display->y_pos - y_pos;

1383

1384 clut = get_clut(ctx, region->clut);

1385

1386 if (clut == 0)

1387 clut = &default_clut;

1388

1389 switch (region->depth) {

1390 case 2:

1391 clut_table = clut->clut4;

1392 break;

1393 case 8:

1394 clut_table = clut->clut256;

1395 break;

1396 case 4:

1397 default:

1398 clut_table = clut->clut16;

1399 break;

1400 }

1401

1402 for (y = 0; y < region->height; y++) {

1403 for (x = 0; x < region->width; x++) {

1404 pbuf[((y + y_off) * width) + x_off + x] =

1405 clut_table[region->pbuf[y * region->width + x]];

1406 }

1407 }

1408

1409 }

1410

1411 snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);

1412

1413 png_save2(filename, pbuf, width, height);

1414

1415 av_free(pbuf);

1416 }

1417

1418 fileno_index++;

1419 }

1420 #endif

1421

1422 static void dvbsub_parse_display_definition_segment(AVCodecContext *avctx,

1423 const uint8_t *buf,

1424 int buf_size)

1425 {

1426 DVBSubContext *ctx = avctx->priv_data;

1427 DVBSubDisplayDefinition *display_def = ctx->display_definition;

1428 int dds_version, info_byte;

1429

1430 if (buf_size < 5)

1431 return;

1432

1433 info_byte = bytestream_get_byte(&buf);

1434 dds_version = info_byte >> 4;

1435 if (display_def && display_def->version == dds_version)

1436 return; // already have this display definition version

1437

1438 if (!display_def) {

1439 display_def = av_mallocz(sizeof(*display_def));

1440 ctx->display_definition = display_def;

1441 }

1442 if (!display_def)

1443 return;

1444

1445 display_def->version = dds_version;

1446 display_def->x = 0;

1447 display_def->y = 0;

1448 display_def->width = bytestream_get_be16(&buf) + 1;

1449 display_def->height = bytestream_get_be16(&buf) + 1;

1450 if (!avctx->width || !avctx->height) {

1451 avctx->width = display_def->width;

1452 avctx->height = display_def->height;

1453 }

1454

1455 if (buf_size < 13)

1456 return;

1457

1458 if (info_byte & 1<<3) { // display_window_flag

1459 display_def->x = bytestream_get_be16(&buf);

1460 display_def->width = bytestream_get_be16(&buf) - display_def->x + 1;

1461 display_def->y = bytestream_get_be16(&buf);

1462 display_def->height = bytestream_get_be16(&buf) - display_def->y + 1;

1463 }

1464 }

1465

1466 static void dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,

1467 int buf_size, AVSubtitle *sub,int *got_output)

1468 {

1469 DVBSubContext *ctx = avctx->priv_data;

1470

1471 if(ctx->compute_edt == 0)

1472 save_subtitle_set(avctx, sub, got_output);

1473 #ifdef DEBUG

1474 save_display_set(ctx);

1475 #endif

1476

1477 }

1478

1479 static int dvbsub_decode(AVCodecContext *avctx,

1480 void *data, int *data_size,

1481 AVPacket *avpkt)

1482 {

1483 const uint8_t *buf = avpkt->data;

1484 int buf_size = avpkt->size;

1485 DVBSubContext *ctx = avctx->priv_data;

1486 AVSubtitle *sub = data;

1487 const uint8_t *p, *p_end;

1488 int segment_type;

1489 int page_id;

1490 int segment_length;

1491 int i;

1492 int ret = 0;

1493 int got_segment = 0;

1494

1495 av_dlog(avctx, "DVB sub packet:\n");

1496

1497 for (i=0; i < buf_size; i++) {

1498 av_dlog(avctx, "%02x ", buf[i]);

1499 if (i % 16 == 15)

1500 av_dlog(avctx, "\n");

1501 }

1502

1503 if (i % 16)

1504 av_dlog(avctx, "\n");

1505

1506 if (buf_size <= 6 || *buf != 0x0f) {

1507 av_dlog(avctx, "incomplete or broken packet");

1508 return -1;

1509 }

1510

1511 p = buf;

1512 p_end = buf + buf_size;

1513

1514 while (p_end - p >= 6 && *p == 0x0f) {

1515 p += 1;

1516 segment_type = *p++;

1517 page_id = AV_RB16(p);

1518 p += 2;

1519 segment_length = AV_RB16(p);

1520 p += 2;

1521

1522 if (avctx->debug & FF_DEBUG_STARTCODE) {

1523 av_log(avctx, AV_LOG_DEBUG, "segment_type:%d page_id:%d segment_length:%d\n", segment_type, page_id, segment_length);

1524 }

1525

1526 if (p_end - p < segment_length) {

1527 av_dlog(avctx, "incomplete or broken packet");

1528 ret = -1;

1529 goto end;

1530 }

1531

1532 if (page_id == ctx->composition_id || page_id == ctx->ancillary_id ||

1533 ctx->composition_id == -1 || ctx->ancillary_id == -1) {

1534 switch (segment_type) {

1535 case DVBSUB_PAGE_SEGMENT:

1536 dvbsub_parse_page_segment(avctx, p, segment_length, sub, data_size);

1537 got_segment |= 1;

1538 break;

1539 case DVBSUB_REGION_SEGMENT:

1540 dvbsub_parse_region_segment(avctx, p, segment_length);

1541 got_segment |= 2;

1542 break;

1543 case DVBSUB_CLUT_SEGMENT:

1544 ret = dvbsub_parse_clut_segment(avctx, p, segment_length);

1545 if (ret < 0) goto end;

1546 got_segment |= 4;

1547 break;

1548 case DVBSUB_OBJECT_SEGMENT:

1549 dvbsub_parse_object_segment(avctx, p, segment_length);

1550 got_segment |= 8;

1551 break;

1552 case DVBSUB_DISPLAYDEFINITION_SEGMENT:

1553 dvbsub_parse_display_definition_segment(avctx, p, segment_length);

1554 break;

1555 case DVBSUB_DISPLAY_SEGMENT:

1556 dvbsub_display_end_segment(avctx, p, segment_length, sub, data_size);

1557 got_segment |= 16;

1558 break;

1559 default:

1560 av_dlog(avctx, "Subtitling segment type 0x%x, page id %d, length %d\n",

1561 segment_type, page_id, segment_length);

1562 break;

1563 }

1564 }

1565

1566 p += segment_length;

1567 }

1568 // Some streams do not send a display segment but if we have all the other

1569 // segments then we need no further data.

1570 if (got_segment == 15) {

1571 av_log(avctx, AV_LOG_DEBUG, "Missing display_end_segment, emulating\n");

1572 dvbsub_display_end_segment(avctx, p, 0, sub, data_size);

1573 }

1574

1575 end:

1576 if(ret < 0) {

1577 *data_size = 0;

1578 avsubtitle_free(sub);

1579 return ret;

1580 } else {

1581 if(ctx->compute_edt == 1 )

1582 FFSWAP(int64_t, ctx->prev_start, sub->pts);

1583 }

1584

1585 return p - buf;

1586 }

1587

1588 static const AVOption options[] = {

1589 {"compute_edt", "compute end of time using pts or timeout", offsetof(DVBSubContext, compute_edt), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, 0},

1590 {NULL}

1591 };

1592 static const AVClass dvbsubdec_class = {

1593 .class_name = "DVB Sub Decoder",

1594 .item_name = av_default_item_name,

1595 .option = options,

1596 .version = LIBAVUTIL_VERSION_INT,

1597 };

1598

1599 AVCodec ff_dvbsub_decoder = {

1600 .name = "dvbsub",

1601 .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),

1602 .type = AVMEDIA_TYPE_SUBTITLE,

1603 .id = AV_CODEC_ID_DVB_SUBTITLE,

1604 .priv_data_size = sizeof(DVBSubContext),

1605 .init = dvbsub_init_decoder,

1606 .close = dvbsub_close_decoder,

1607 .decode = dvbsub_decode,

1608 .priv_class = &dvbsubdec_class,

1609 };

Generated on Sun Jul 20 2014 23:05:46 for FFmpeg by doxygen 1.8.2