main.c
上传用户:lctgjx
上传日期:2022-06-04
资源大小:8887k
文件大小:7k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

Visual C++

  1. /********************************************************************
  2. created: 2008/06/23
  3. filename:  main.c
  4. author: xcl
  5. purpose: testbed for h264 decoder
  6. *********************************************************************/
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <math.h>
  11. #include "dsputil.h"
  12. #include "h264.h"
  13. #define PI 3.14159265358979323846
  14. #ifdef HAVE_AV_CONFIG_H
  15. #undef HAVE_AV_CONFIG_H
  16. #endif
  17. #include "avcodec.h"
  18. #include "define.h"
  19. #define INBUF_SIZE 4096
  20. void pgm_save(unsigned char *buf,int wrap, int xsize,int ysize,char *filename, char *recfilename)
  21. {
  22.     FILE *f;
  23.     int i,j;
  24. int ci=0;
  25. #if 0   //不保存outrec.txt文件,提高速度 --@lia
  26. static int framenum =0;
  27. if(framenum == 3*0)
  28. {
  29. f=fopen(filename,"r+");
  30. fprintf(f,"P5n%d %dn%dn",xsize,ysize,255);
  31. //  for(i=0;i<ysize;i++)
  32. //      fwrite(buf + i * wrap,1,xsize,f);
  33. for(i=0;i<ysize;i++)
  34. {
  35. for (j=0; j < xsize; j++)
  36. {
  37. fprintf(f, "%3d(%3d,%3d)",*(buf + i * wrap+j),i,j);
  38. if(ci++%5==0)
  39. fprintf(f, "n");
  40. }
  41. fprintf(f, "n");
  42. }
  43. fclose(f);
  44. }
  45. #endif //不保存outrec.txt文件,提高速度 --@lia
  46. f=fopen(recfilename,"ab+");   
  47. for(i=0;i<ysize;i++)
  48. {
  49. fwrite(buf + i * wrap, 1, xsize, f );
  50. // for (j=0; j < xsize; j++)
  51. // {    
  52. // fprintf(f, "%d(%d,%d)",*(buf + i * wrap+j),i,j);  
  53. // }   
  54. }
  55.     fclose(f);
  56. }
  57. int main(int argc, char **argv)
  58. {
  59. const char *outfilename = "../OutPut/outrec.txt";
  60. const char *outrecfilename = "../OutPut/outrec.yuv";
  61. const char *filename = "../OutPut/test.264";
  62.     extern AVCodec h264_decoder;
  63.     AVCodec *codec = &h264_decoder;
  64.     AVCodecContext *c= NULL;
  65.     int frame, size, got_picture, len;
  66.     FILE *fin, *fout;
  67.     AVFrame *picture;
  68.     uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE], *inbuf_ptr;
  69.     char buf[1024]; 
  70. DSPContext dsp;
  71.    
  72.     
  73.    
  74.     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
  75.     memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
  76.     printf("Video decodingn");
  77.     /* find the mpeg1 video decoder */
  78.     avcodec_init();
  79.     c= avcodec_alloc_context();
  80.     picture= avcodec_alloc_frame();
  81. //  dsputil_init(&dsp, c);
  82.     if(codec->capabilities&CODEC_CAP_TRUNCATED)
  83.         c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
  84.     /* For some codecs, such as msmpeg4 and mpeg4, width and height
  85.        MUST be initialized there because this information is not
  86.        available in the bitstream. */
  87.     /* open it */
  88.   
  89.   
  90.     if (avcodec_open(c, codec) < 0) {
  91.         fprintf(stderr, "could not open codecn");
  92.         exit(1);
  93.     }
  94.   {
  95.    
  96.    H264Context *h = c->priv_data;
  97.       MpegEncContext *s = &h->s;
  98.       s->dsp.idct_permutation_type =1;
  99.   dsputil_init(&s->dsp, c);
  100.    }
  101.     /* the codec gives us the frame size, in samples */
  102.     fin = fopen(filename, "rb");
  103.     if (!fin) {
  104.         fprintf(stderr, "could not open %sn", filename);
  105.         exit(1);
  106.     }
  107.     fout = fopen(outfilename, "wb");
  108.     if (!fin) {
  109.         fprintf(stderr, "could not open %sn", outfilename);
  110.         exit(1);
  111.     }
  112. fclose(fout);
  113. fout = fopen(outrecfilename, "wb");
  114.     if (!fin) {
  115.         fprintf(stderr, "could not open %sn", outrecfilename);
  116.         exit(1);
  117.     }
  118. fclose(fout);
  119.     frame = 0;
  120.     for(;;) {
  121.         size = fread(inbuf, 1, INBUF_SIZE, fin);
  122.         if (size == 0)
  123.             break;
  124.         /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
  125.            and this is the only method to use them because you cannot
  126.            know the compressed data size before analysing it.
  127.            BUT some other codecs (msmpeg4, mpeg4) are inherently frame
  128.            based, so you must call them with all the data for one
  129.            frame exactly. You must also initialize 'width' and
  130.            'height' before initializing them. */
  131.         /* NOTE2: some codecs allow the raw parameters (frame size,
  132.            sample rate) to be changed at any frame. We handle this, so
  133.            you should also take care of it */
  134.         /* here, we use a stream based decoder (mpeg1video), so we
  135.            feed decoder and see if it could decode a frame */
  136.         inbuf_ptr = inbuf;
  137.         while (size > 0) {
  138.             len = avcodec_decode_video(c, picture, &got_picture,
  139.                                        inbuf_ptr, size);
  140.             if (len < 0) {
  141.                 fprintf(stderr, "Error while decoding frame %dn", frame);
  142.                 exit(1);
  143.             }
  144.             if (got_picture) {
  145.                 printf("saving frame %3dn", frame);
  146.                 fflush(stdout);
  147.                 /* the picture is allocated by the decoder. no need to
  148.                    free it */
  149.               //  snprintf(buf, sizeof(buf), outfilename, frame);
  150.                 pgm_save(picture->data[0], picture->linesize[0],
  151.                          c->width, c->height, outfilename, outrecfilename);
  152. pgm_save(picture->data[1], picture->linesize[1],
  153.                          c->width/2, c->height/2, outfilename, outrecfilename);
  154. pgm_save(picture->data[2], picture->linesize[2],
  155.                          c->width/2, c->height/2, outfilename, outrecfilename);
  156.                 frame++;
  157.             }
  158.             size -= len;
  159.             inbuf_ptr += len;
  160.         }
  161.     }
  162.     /* some codecs, such as MPEG, transmit the I and P frame with a
  163.        latency of one frame. You must do the following to have a
  164.        chance to get the last frame of the video */
  165. #define NOTFOR264
  166. #ifdef NOTFOR264
  167. //    len = avcodec_decode_video(c, picture, &got_picture,
  168. //                               NULL, 0);
  169. len = avcodec_decode_video(c, picture, &got_picture,
  170.                                inbuf_ptr, 0);
  171.     if (got_picture) {
  172.         printf("saving last frame %3dn", frame);
  173.         fflush(stdout);
  174.         /* the picture is allocated by the decoder. no need to
  175.            free it */
  176.     //    snprintf(buf, sizeof(buf), outfilename, frame);
  177.          pgm_save(picture->data[0], picture->linesize[0],
  178.                          c->width, c->height, outfilename, outrecfilename);
  179. pgm_save(picture->data[1], picture->linesize[1],
  180.                          c->width/2, c->height/2, outfilename, outrecfilename);
  181. pgm_save(picture->data[2], picture->linesize[2],
  182.                          c->width/2, c->height/2, outfilename, outrecfilename);
  183.                 frame++;
  184.     }
  185. #endif
  186.     fclose(fin);
  187. //  fclose(fout);
  188.     avcodec_close(c);
  189.     av_free(c);
  190.     av_free(picture);
  191.     printf("n");
  192. }