FFmpeg: doc/examples/decoding_encoding.c Source File

FFmpeg

[フレーム]

decoding_encoding.c

Go to the documentation of this file.

1 /*

3 *

4 * Permission is hereby granted, free of charge, to any person obtaining a copy

5 * of this software and associated documentation files (the "Software"), to deal

6 * in the Software without restriction, including without limitation the rights

7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8 * copies of the Software, and to permit persons to whom the Software is

9 * furnished to do so, subject to the following conditions:

10 *

11 * The above copyright notice and this permission notice shall be included in

12 * all copies or substantial portions of the Software.

13 *

14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20 * THE SOFTWARE.

21 */

23 /**

24 * @file

25 * libavcodec API use example.

26 *

27 * Note that libavcodec only handles codecs (mpeg, mpeg4, etc...),

28 * not file formats (avi, vob, mp4, mov, mkv, mxf, flv, mpegts, mpegps, etc...). See library 'libavformat' for the

29 * format handling

30 * @example doc/examples/decoding_encoding.c

31 */

33 #include <math.h>

35 #include <libavutil/opt.h>

36 #include <libavcodec/avcodec.h>

37 #include <libavutil/channel_layout.h>

38 #include <libavutil/common.h>

39 #include <libavutil/imgutils.h>

40 #include <libavutil/mathematics.h>

41 #include <libavutil/samplefmt.h>

43 #define INBUF_SIZE 4096

44 #define AUDIO_INBUF_SIZE 20480

45 #define AUDIO_REFILL_THRESH 4096

47 /* check that a given sample format is supported by the encoder */

48 static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)

49 {

50 const enum AVSampleFormat *p = codec->sample_fmts;

52 while (*p != AV_SAMPLE_FMT_NONE) {

53 if (*p == sample_fmt)

54 return 1;

55 p++;

56 }

57 return 0;

58 }

60 /* just pick the highest supported samplerate */

61 static int select_sample_rate(AVCodec *codec)

62 {

63 const int *p;

64 int best_samplerate = 0;

66 if (!codec->supported_samplerates)

67 return 44100;

69 p = codec->supported_samplerates;

70 while (*p) {

71 best_samplerate = FFMAX(*p, best_samplerate);

72 p++;

73 }

74 return best_samplerate;

75 }

77 /* select layout with the highest channel count */

78 static int select_channel_layout(AVCodec *codec)

79 {

80 const uint64_t *p;

81 uint64_t best_ch_layout = 0;

82 int best_nb_channels = 0;

84 if (!codec->channel_layouts)

85 return AV_CH_LAYOUT_STEREO;

87 p = codec->channel_layouts;

88 while (*p) {

89 int nb_channels = av_get_channel_layout_nb_channels(*p);

91 if (nb_channels > best_nb_channels) {

92 best_ch_layout = *p;

93 best_nb_channels = nb_channels;

94 }

95 p++;

96 }

97 return best_ch_layout;

98 }

100 /*

101 * Audio encoding example

102 */

103 static void audio_encode_example(const char *filename)

104 {

105 AVCodec *codec;

106 AVCodecContext *c= NULL;

107 AVFrame *frame;

108 AVPacket pkt;

109 int i, j, k, ret, got_output;

110 int buffer_size;

111 FILE *f;

112 uint16_t *samples;

113 float t, tincr;

114

115 printf("Encode audio file %s\n", filename);

116

117 /* find the MP2 encoder */

118 codec = avcodec_find_encoder(AV_CODEC_ID_MP2);

119 if (!codec) {

120 fprintf(stderr, "Codec not found\n");

121 exit(1);

122 }

123

124 c = avcodec_alloc_context3(codec);

125 if (!c) {

126 fprintf(stderr, "Could not allocate audio codec context\n");

127 exit(1);

128 }

129

130 /* put sample parameters */

131 c->bit_rate = 64000;

132

133 /* check that the encoder supports s16 pcm input */

134 c->sample_fmt = AV_SAMPLE_FMT_S16;

135 if (!check_sample_fmt(codec, c->sample_fmt)) {

136 fprintf(stderr, "Encoder does not support sample format %s",

137 av_get_sample_fmt_name(c->sample_fmt));

138 exit(1);

139 }

140

141 /* select other audio parameters supported by the encoder */

142 c->sample_rate = select_sample_rate(codec);

143 c->channel_layout = select_channel_layout(codec);

144 c->channels = av_get_channel_layout_nb_channels(c->channel_layout);

145

146 /* open it */

147 if (avcodec_open2(c, codec, NULL) < 0) {

148 fprintf(stderr, "Could not open codec\n");

149 exit(1);

150 }

151

152 f = fopen(filename, "wb");

153 if (!f) {

154 fprintf(stderr, "Could not open %s\n", filename);

155 exit(1);

156 }

157

158 /* frame containing input raw audio */

159 frame = avcodec_alloc_frame();

160 if (!frame) {

161 fprintf(stderr, "Could not allocate audio frame\n");

162 exit(1);

163 }

164

165 frame->nb_samples = c->frame_size;

166 frame->format = c->sample_fmt;

167 frame->channel_layout = c->channel_layout;

168

169 /* the codec gives us the frame size, in samples,

170 * we calculate the size of the samples buffer in bytes */

171 buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,

172 c->sample_fmt, 0);

173 samples = av_malloc(buffer_size);

174 if (!samples) {

175 fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",

176 buffer_size);

177 exit(1);

178 }

179 /* setup the data pointers in the AVFrame */

180 ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,

181 (const uint8_t*)samples, buffer_size, 0);

182 if (ret < 0) {

183 fprintf(stderr, "Could not setup audio frame\n");

184 exit(1);

185 }

186

187 /* encode a single tone sound */

188 t = 0;

189 tincr = 2 * M_PI * 440.0 / c->sample_rate;

190 for(i=0;i<200;i++) {

191 av_init_packet(&pkt);

192 pkt.data = NULL; // packet data will be allocated by the encoder

193 pkt.size = 0;

194

195 for (j = 0; j < c->frame_size; j++) {

196 samples[2*j] = (int)(sin(t) * 10000);

197

198 for (k = 1; k < c->channels; k++)

199 samples[2*j + k] = samples[2*j];

200 t += tincr;

201 }

202 /* encode the samples */

203 ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);

204 if (ret < 0) {

205 fprintf(stderr, "Error encoding audio frame\n");

206 exit(1);

207 }

208 if (got_output) {

209 fwrite(pkt.data, 1, pkt.size, f);

210 av_free_packet(&pkt);

211 }

212 }

213

214 /* get the delayed frames */

215 for (got_output = 1; got_output; i++) {

216 ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);

217 if (ret < 0) {

218 fprintf(stderr, "Error encoding frame\n");

219 exit(1);

220 }

221

222 if (got_output) {

223 fwrite(pkt.data, 1, pkt.size, f);

224 av_free_packet(&pkt);

225 }

226 }

227 fclose(f);

228

229 av_freep(&samples);

230 avcodec_free_frame(&frame);

231 avcodec_close(c);

232 av_free(c);

233 }

234

235 /*

236 * Audio decoding.

237 */

238 static void audio_decode_example(const char *outfilename, const char *filename)

239 {

240 AVCodec *codec;

241 AVCodecContext *c= NULL;

242 int len;

243 FILE *f, *outfile;

244 uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];

245 AVPacket avpkt;

246 AVFrame *decoded_frame = NULL;

247

248 av_init_packet(&avpkt);

249

250 printf("Decode audio file %s to %s\n", filename, outfilename);

251

252 /* find the mpeg audio decoder */

253 codec = avcodec_find_decoder(AV_CODEC_ID_MP2);

254 if (!codec) {

255 fprintf(stderr, "Codec not found\n");

256 exit(1);

257 }

258

259 c = avcodec_alloc_context3(codec);

260 if (!c) {

261 fprintf(stderr, "Could not allocate audio codec context\n");

262 exit(1);

263 }

264

265 /* open it */

266 if (avcodec_open2(c, codec, NULL) < 0) {

267 fprintf(stderr, "Could not open codec\n");

268 exit(1);

269 }

270

271 f = fopen(filename, "rb");

272 if (!f) {

273 fprintf(stderr, "Could not open %s\n", filename);

274 exit(1);

275 }

276 outfile = fopen(outfilename, "wb");

277 if (!outfile) {

278 av_free(c);

279 exit(1);

280 }

281

282 /* decode until eof */

283 avpkt.data = inbuf;

284 avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);

285

286 while (avpkt.size > 0) {

287 int got_frame = 0;

288

289 if (!decoded_frame) {

290 if (!(decoded_frame = avcodec_alloc_frame())) {

291 fprintf(stderr, "Could not allocate audio frame\n");

292 exit(1);

293 }

294 } else

295 avcodec_get_frame_defaults(decoded_frame);

296

297 len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);

298 if (len < 0) {

299 fprintf(stderr, "Error while decoding\n");

300 exit(1);

301 }

302 if (got_frame) {

303 /* if a frame has been decoded, output it */

304 int data_size = av_samples_get_buffer_size(NULL, c->channels,

305 decoded_frame->nb_samples,

306 c->sample_fmt, 1);

307 fwrite(decoded_frame->data[0], 1, data_size, outfile);

308 }

309 avpkt.size -= len;

310 avpkt.data += len;

311 avpkt.dts =

312 avpkt.pts = AV_NOPTS_VALUE;

313 if (avpkt.size < AUDIO_REFILL_THRESH) {

314 /* Refill the input buffer, to avoid trying to decode

315 * incomplete frames. Instead of this, one could also use

316 * a parser, or use a proper container format through

317 * libavformat. */

318 memmove(inbuf, avpkt.data, avpkt.size);

319 avpkt.data = inbuf;

320 len = fread(avpkt.data + avpkt.size, 1,

321 AUDIO_INBUF_SIZE - avpkt.size, f);

322 if (len > 0)

323 avpkt.size += len;

324 }

325 }

326

327 fclose(outfile);

328 fclose(f);

329

330 avcodec_close(c);

331 av_free(c);

332 avcodec_free_frame(&decoded_frame);

333 }

334

335 /*

336 * Video encoding example

337 */

338 static void video_encode_example(const char *filename, int codec_id)

339 {

340 AVCodec *codec;

341 AVCodecContext *c= NULL;

342 int i, ret, x, y, got_output;

343 FILE *f;

344 AVFrame *frame;

345 AVPacket pkt;

346 uint8_t endcode[] = { 0, 0, 1, 0xb7 };

347

348 printf("Encode video file %s\n", filename);

349

350 /* find the mpeg1 video encoder */

351 codec = avcodec_find_encoder(codec_id);

352 if (!codec) {

353 fprintf(stderr, "Codec not found\n");

354 exit(1);

355 }

356

357 c = avcodec_alloc_context3(codec);

358 if (!c) {

359 fprintf(stderr, "Could not allocate video codec context\n");

360 exit(1);

361 }

362

363 /* put sample parameters */

364 c->bit_rate = 400000;

365 /* resolution must be a multiple of two */

366 c->width = 352;

367 c->height = 288;

368 /* frames per second */

369 c->time_base= (AVRational){1,25};

370 c->gop_size = 10; /* emit one intra frame every ten frames */

371 c->max_b_frames=1;

372 c->pix_fmt = AV_PIX_FMT_YUV420P;

373

374 if(codec_id == AV_CODEC_ID_H264)

375 av_opt_set(c->priv_data, "preset", "slow", 0);

376

377 /* open it */

378 if (avcodec_open2(c, codec, NULL) < 0) {

379 fprintf(stderr, "Could not open codec\n");

380 exit(1);

381 }

382

383 f = fopen(filename, "wb");

384 if (!f) {

385 fprintf(stderr, "Could not open %s\n", filename);

386 exit(1);

387 }

388

389 frame = avcodec_alloc_frame();

390 if (!frame) {

391 fprintf(stderr, "Could not allocate video frame\n");

392 exit(1);

393 }

394 frame->format = c->pix_fmt;

395 frame->width = c->width;

396 frame->height = c->height;

397

398 /* the image can be allocated by any means and av_image_alloc() is

399 * just the most convenient way if av_malloc() is to be used */

400 ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,

401 c->pix_fmt, 32);

402 if (ret < 0) {

403 fprintf(stderr, "Could not allocate raw picture buffer\n");

404 exit(1);

405 }

406

407 /* encode 1 second of video */

408 for(i=0;i<25;i++) {

409 av_init_packet(&pkt);

410 pkt.data = NULL; // packet data will be allocated by the encoder

411 pkt.size = 0;

412

413 fflush(stdout);

414 /* prepare a dummy image */

415 /* Y */

416 for(y=0;y<c->height;y++) {

417 for(x=0;x<c->width;x++) {

418 frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;

419 }

420 }

421

422 /* Cb and Cr */

423 for(y=0;y<c->height/2;y++) {

424 for(x=0;x<c->width/2;x++) {

425 frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;

426 frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;

427 }

428 }

429

430 frame->pts = i;

431

432 /* encode the image */

433 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);

434 if (ret < 0) {

435 fprintf(stderr, "Error encoding frame\n");

436 exit(1);

437 }

438

439 if (got_output) {

440 printf("Write frame %3d (size=%5d)\n", i, pkt.size);

441 fwrite(pkt.data, 1, pkt.size, f);

442 av_free_packet(&pkt);

443 }

444 }

445

446 /* get the delayed frames */

447 for (got_output = 1; got_output; i++) {

448 fflush(stdout);

449

450 ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);

451 if (ret < 0) {

452 fprintf(stderr, "Error encoding frame\n");

453 exit(1);

454 }

455

456 if (got_output) {

457 printf("Write frame %3d (size=%5d)\n", i, pkt.size);

458 fwrite(pkt.data, 1, pkt.size, f);

459 av_free_packet(&pkt);

460 }

461 }

462

463 /* add sequence end code to have a real mpeg file */

464 fwrite(endcode, 1, sizeof(endcode), f);

465 fclose(f);

466

467 avcodec_close(c);

468 av_free(c);

469 av_freep(&frame->data[0]);

470 avcodec_free_frame(&frame);

471 printf("\n");

472 }

473

474 /*

475 * Video decoding example

476 */

477

478 static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,

479 char *filename)

480 {

481 FILE *f;

482 int i;

483

484 f=fopen(filename,"w");

485 fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);

486 for(i=0;i<ysize;i++)

487 fwrite(buf + i * wrap,1,xsize,f);

488 fclose(f);

489 }

490

491 static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,

492 AVFrame *frame, int *frame_count, AVPacket *pkt, int last)

493 {

494 int len, got_frame;

495 char buf[1024];

496

497 len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);

498 if (len < 0) {

499 fprintf(stderr, "Error while decoding frame %d\n", *frame_count);

500 return len;

501 }

502 if (got_frame) {

503 printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);

504 fflush(stdout);

505

506 /* the picture is allocated by the decoder, no need to free it */

507 snprintf(buf, sizeof(buf), outfilename, *frame_count);

508 pgm_save(frame->data[0], frame->linesize[0],

509 avctx->width, avctx->height, buf);

510 (*frame_count)++;

511 }

512 if (pkt->data) {

513 pkt->size -= len;

514 pkt->data += len;

515 }

516 return 0;

517 }

518

519 static void video_decode_example(const char *outfilename, const char *filename)

520 {

521 AVCodec *codec;

522 AVCodecContext *c= NULL;

523 int frame_count;

524 FILE *f;

525 AVFrame *frame;

526 uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];

527 AVPacket avpkt;

528

529 av_init_packet(&avpkt);

530

531 /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */

532 memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);

533

534 printf("Decode video file %s to %s\n", filename, outfilename);

535

536 /* find the mpeg1 video decoder */

537 codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);

538 if (!codec) {

539 fprintf(stderr, "Codec not found\n");

540 exit(1);

541 }

542

543 c = avcodec_alloc_context3(codec);

544 if (!c) {

545 fprintf(stderr, "Could not allocate video codec context\n");

546 exit(1);

547 }

548

549 if(codec->capabilities&CODEC_CAP_TRUNCATED)

550 c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */

551

552 /* For some codecs, such as msmpeg4 and mpeg4, width and height

553 MUST be initialized there because this information is not

554 available in the bitstream. */

555

556 /* open it */

557 if (avcodec_open2(c, codec, NULL) < 0) {

558 fprintf(stderr, "Could not open codec\n");

559 exit(1);

560 }

561

562 f = fopen(filename, "rb");

563 if (!f) {

564 fprintf(stderr, "Could not open %s\n", filename);

565 exit(1);

566 }

567

568 frame = avcodec_alloc_frame();

569 if (!frame) {

570 fprintf(stderr, "Could not allocate video frame\n");

571 exit(1);

572 }

573

574 frame_count = 0;

575 for(;;) {

576 avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);

577 if (avpkt.size == 0)

578 break;

579

580 /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)

581 and this is the only method to use them because you cannot

582 know the compressed data size before analysing it.

583

584 BUT some other codecs (msmpeg4, mpeg4) are inherently frame

585 based, so you must call them with all the data for one

586 frame exactly. You must also initialize 'width' and

587 'height' before initializing them. */

588

589 /* NOTE2: some codecs allow the raw parameters (frame size,

590 sample rate) to be changed at any frame. We handle this, so

591 you should also take care of it */

592

593 /* here, we use a stream based decoder (mpeg1video), so we

594 feed decoder and see if it could decode a frame */

595 avpkt.data = inbuf;

596 while (avpkt.size > 0)

597 if (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)

598 exit(1);

599 }

600

601 /* some codecs, such as MPEG, transmit the I and P frame with a

602 latency of one frame. You must do the following to have a

603 chance to get the last frame of the video */

604 avpkt.data = NULL;

605 avpkt.size = 0;

606 decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 1);

607

608 fclose(f);

609

610 avcodec_close(c);

611 av_free(c);

612 avcodec_free_frame(&frame);

613 printf("\n");

614 }

615

616 int main(int argc, char **argv)

617 {

618 const char *output_type;

619

620 /* register all the codecs */

621 avcodec_register_all();

622

623 if (argc < 2) {

624 printf("usage: %s output_type\n"

625 "API example program to decode/encode a media stream with libavcodec.\n"

626 "This program generates a synthetic stream and encodes it to a file\n"

627 "named test.h264, test.mp2 or test.mpg depending on output_type.\n"

628 "The encoded stream is then decoded and written to a raw data output.\n"

629 "output_type must be choosen between 'h264', 'mp2', 'mpg'.\n",

630 argv[0]);

631 return 1;

632 }

633 output_type = argv[1];

634

635 if (!strcmp(output_type, "h264")) {

636 video_encode_example("test.h264", AV_CODEC_ID_H264);

637 } else if (!strcmp(output_type, "mp2")) {

638 audio_encode_example("test.mp2");

639 audio_decode_example("test.sw", "test.mp2");

640 } else if (!strcmp(output_type, "mpg")) {

641 video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);

642 video_decode_example("test%02d.pgm", "test.mpg");

643 } else {

644 fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",

645 output_type);

646 return 1;

647 }

648

649 return 0;

650 }

Generated on Sat Jan 25 2014 19:51:42 for FFmpeg by doxygen 1.8.2