Ticket #3194: decoding_encoding.c

File decoding_encoding.c, 20.1 KB (added by Andrey, 13 years ago)

file for test, only decoder initialization

Line 
1/*
2 * Copyright (c) 2001 Fabrice Bellard
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 */
22
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 */
32
33#include <math.h>
34
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>
42
43#define INBUF_SIZE 4096
44#define AUDIO_INBUF_SIZE 20480
45#define AUDIO_REFILL_THRESH 4096
46
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;
51//
52// while (*p != AV_SAMPLE_FMT_NONE) {
53// if (*p == sample_fmt)
54// return 1;
55// p++;
56// }
57// return 0;
58// }
59
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;
65//
66// if (!codec->supported_samplerates)
67// return 44100;
68//
69// p = codec->supported_samplerates;
70// while (*p) {
71// best_samplerate = FFMAX(*p, best_samplerate);
72// p++;
73// }
74// return best_samplerate;
75// }
76
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;
83//
84// if (!codec->channel_layouts)
85// return AV_CH_LAYOUT_STEREO;
86//
87// p = codec->channel_layouts;
88// while (*p) {
89// int nb_channels = av_get_channel_layout_nb_channels(*p);
90//
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// }
99
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 = av_frame_alloc();
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 = av_frame_alloc())) {
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 = av_frame_alloc();
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
519static 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_H264);
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 = av_frame_alloc();
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
616int 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 video_decode_example("test.264", "test.yuv");
636
637// if (!strcmp(output_type, "h264")) {
638// video_encode_example("test.h264", AV_CODEC_ID_H264);
639// } else if (!strcmp(output_type, "mp2")) {
640// audio_encode_example("test.mp2");
641// audio_decode_example("test.sw", "test.mp2");
642// } else if (!strcmp(output_type, "mpg")) {
643// video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);
644// video_decode_example("test%02d.pgm", "test.mpg");
645// } else {
646// fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",
647// output_type);
648// return 1;
649// }
650
651 return 0;
652}