Recherche avancée

Sur d’autres sites (9678)

• Error using FFMPEG to convert each input image into H264 compiling in Visual Studio running in MevisLab

  21 février 2014, par user3012914

  I am creating a ML Module in MevisLab Framework, I am using FFMPEG to convert each image i get into a H264 Video and save it after I get all the frames. But unfortunately I have problem allocating the output buffer size. The application crashes when I include this in my code.If I am not including it, the output file size is just 4kb. Nothing is stored in it.

  I am also not very sure whether it is correct way of getting the HBitmap into the Encoder. Would be great to have your suggestions.

  My Code :

  BITMAPINFO bitmapInfo;
  
              HDC        hdc;
  
  
  
              ZeroMemory(&bitmapInfo, sizeof(bitmapInfo));
  
  
  
              BITMAPINFOHEADER &bitmapInfoHeader = bitmapInfo.bmiHeader;
  
              bitmapInfoHeader.biSize            = sizeof(bitmapInfoHeader);
  
              bitmapInfoHeader.biWidth           = _imgWidth;
  
              bitmapInfoHeader.biHeight          = _imgHeight;
  
              bitmapInfoHeader.biPlanes          =  1;
  
              bitmapInfoHeader.biBitCount        = 24;
  
              bitmapInfoHeader.biCompression     = BI_RGB;
  
              bitmapInfoHeader.biSizeImage       = ((bitmapInfoHeader.biWidth * bitmapInfoHeader.biBitCount / 8 + 3) & 0xFFFFFFFC) * bitmapInfoHeader.biHeight;
  
              bitmapInfoHeader.biXPelsPerMeter   = 10000;
  
              bitmapInfoHeader.biYPelsPerMeter   = 10000;
  
              bitmapInfoHeader.biClrUsed         = 0;
  
              bitmapInfoHeader.biClrImportant    = 0;
  
              //RGBQUAD* Ref = new RGBQUAD[_imgWidth,_imgHeight];
  
              HDC hdcscreen = GetDC(0);
  
  
  
              hdc = CreateCompatibleDC(hdcscreen);
  
              ReleaseDC(0, hdcscreen);
  
  
  
              _hbitmap = CreateDIBSection(hdc, (BITMAPINFO*) &bitmapInfoHeader, DIB_RGB_COLORS, &_bits, NULL, NULL);

  To get the BitMap I use the above code. Then I allocate the Codec Context as followed

  c->bit_rate = 400000;
  
                  // resolution must be a multiple of two 
  
                  c->width = 1920;
  
                  c->height = 1080;
  
                  // frames per second 
  
                  frame_rate = _framesPerSecondFld->getIntValue();
  
                  //AVRational rational = {1,10};
  
                  //c->time_base = (AVRational){1,25};
  
                   //c->time_base = (AVRational){1,25};
  
                   c->gop_size = 10; // emit one intra frame every ten frames 
  
                   c->max_b_frames = 1;
  
                   c->keyint_min = 1;   //minimum GOP size
  
                   c->time_base.num = 1;                                  // framerate numerator
  
                   c->time_base.den = _framesPerSecondFld->getIntValue(); 
  
                   c->i_quant_factor = (float)0.71;                        // qscale factor between P and I frames
  
                   c->pix_fmt = AV_PIX_FMT_RGB32;
  
                   std::string msg;
  
                   msg.append("Context is stored");
  
                   _messageFld->setStringValue(msg.c_str());

  I create the Bitmap Image as followed from the input

  PagedImage *inImg = getUpdatedInputImage(0);
  
          ML_CHECK(inImg);
  
          ImageVector imgExt = inImg->getImageExtent();
  
          if ((imgExt.x = _imgWidth) && (imgExt.y == _imgHeight))
  
          {
  
          if (((imgExt.x % 4)==0) && ((imgExt.y % 4) == 0))
  
          {
  
                   // read out input image and write output image into video
  
                  // get input image as an array
  
                  void* imgData = NULL;
  
                  SubImageBox imageBox(imgExt); // get the whole image
  
                  getTile(inImg, imageBox, MLuint8Type, &imgData);
  
                  iData = (MLuint8*)imgData;
  
                  int r = 0; int g = 0;int  b = 0;
  
                  // since we have only images with
  
                  // a z-ext of 1, we can compute the c stride as follows
  
                  int cStride = _imgWidth * _imgHeight;
  
                  uint8_t offset  = 0;
  
                  // pointer into the bitmap that is
  
                  // used to write images into the avi
  
                  UCHAR* dst = (UCHAR*)_bits;
  
                  for (int y = _imgHeight-1; y >= 0; y--)
  
                  { // reversely scan the image. if y-rows of DIB are set in normal order, no compression will be available.
  
                      offset = _imgWidth * y;
  
                      for (int x = 0; x < _imgWidth; x++)
  
                      {
  
                          if (_isGreyValueImage)
  
                          {
  
                              r = iData[offset + x];
  
                              *dst++ = (UCHAR)r;
  
                              *dst++ = (UCHAR)r;
  
                              *dst++ = (UCHAR)r;
  
                          } 
  
                          else
  
                          {
  
                              b = iData[offset + x]; // windows bitmap need reverse order: bgr instead of rgb
  
                              g = iData[offset + x + cStride          ];
  
                              r = iData[offset + x + cStride + cStride];
  
  
  
                              *dst++ = (UCHAR)r;
  
                              *dst++ = (UCHAR)g;
  
                              *dst++ = (UCHAR)b;
  
                          }
  
                          // alpha channel in input image is ignored
  
                      }
  
                  }

  Then I add it to the Encoder as followed as write as H264

   in_width   = c->width;
  
                   in_height  = c->height;
  
                   out_width  = c->width;
  
                   out_height = c->height;
  
                   ibytes = avpicture_get_size(PIX_FMT_BGR32, in_width, in_height);
  
                   obytes = avpicture_get_size(PIX_FMT_YUV420P, out_width, out_height);
  
                   outbuf_size = 100000 + c->width*c->height*(32>>3);      // allocate output buffer
  
                   outbuf = static_cast(malloc(outbuf_size));
  
  
  
                   if(!obytes)
  
                   {
  
                       std::string msg;
  
                       msg.append("Bytes cannot be allocated");
  
                       _messageFld->setStringValue(msg.c_str());
  
                   }
  
                   else
  
                   {
  
                       std::string msg;
  
                       msg.append("Bytes allocation done");
  
                       _messageFld->setStringValue(msg.c_str());
  
                   }
  
                   //create buffer for the output image
  
                   inbuffer  =  (uint8_t*)av_malloc(ibytes);
  
                   outbuffer =  (uint8_t*)av_malloc(obytes);
  
                   inbuffer  =  (uint8_t*)dst;
  
  
  
                   //create ffmpeg frame structures.  These do not allocate space for image data, 
  
                   //just the pointers and other information about the image.
  
                   AVFrame* inpic = avcodec_alloc_frame();
  
                   AVFrame* outpic = avcodec_alloc_frame();
  
  
  
                   //this will set the pointers in the frame structures to the right points in 
  
                   //the input and output buffers.
  
                   avpicture_fill((AVPicture*)inpic, inbuffer, PIX_FMT_BGR32, in_width, in_height);
  
                   avpicture_fill((AVPicture*)outpic, outbuffer, PIX_FMT_YUV420P, out_width, out_height);
  
                   av_image_alloc(outpic->data, outpic->linesize, c->width, c->height, c->pix_fmt, 1); 
  
                   inpic->data[0] += inpic->linesize[0]*(_imgHeight-1);                                                      // flipping frame
  
                   inpic->linesize[0] = -inpic->linesize[0];    
  
  
  
                   if(!inpic)
  
                   {
  
                       std::string msg;
  
                       msg.append("Image is empty");
  
                       _messageFld->setStringValue(msg.c_str());
  
                   }
  
                   else
  
                   {
  
                       std::string msg;
  
                       msg.append("Picture has allocations");
  
                       _messageFld->setStringValue(msg.c_str());
  
                   }
  
  
  
                   //create the conversion context
  
                   fooContext = sws_getContext(in_width, in_height, PIX_FMT_BGR32, out_width, out_height, PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);
  
                   //perform the conversion
  
                   sws_scale(fooContext, inpic->data, inpic->linesize, 0, in_height, outpic->data, outpic->linesize);
  
                   //out_size = avcodec_encode_video(c, outbuf,outbuf_size, outpic);
  
                   if(!out_size)
  
                   {
  
                       std::string msg;
  
                       msg.append("Outsize is not valid");
  
                       _messageFld->setStringValue(msg.c_str());
  
                   } 
  
                   else
  
                   {
  
                       std::string msg;
  
                       msg.append("Outsize is valid");
  
                       _messageFld->setStringValue(msg.c_str());
  
                   }
  
                       fwrite(outbuf, 1, out_size, f);
  
                       if(!fwrite)
  
                   {
  
                       std::string msg;
  
                       msg.append("Frames couldnt be written");
  
                       _messageFld->setStringValue(msg.c_str());
  
                   } 
  
                   else
  
                   {
  
                       std::string msg;
  
                       msg.append("Frames written to the file");
  
                       _messageFld->setStringValue(msg.c_str());
  
                   }
  
                      // for (;out_size; i++)
  
                      // {
  
                            out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); 
  
                            std::string msg;                       
  
                            msg.append("Writing Frames");
  
                            _messageFld->setStringValue(msg.c_str());// encode the delayed frames
  
                            _numFramesFld->setIntValue(_numFramesFld->getIntValue()+1);
  
                            fwrite(outbuf, 1, out_size, f);
  
                      // }
  
                       outbuf[0] = 0x00;
  
                       outbuf[1] = 0x00;                                                                                               // add sequence end code to have a real mpeg file
  
                       outbuf[2] = 0x01;
  
                       outbuf[3] = 0xb7;
  
                       fwrite(outbuf, 1, 4, f);
  
  }

  Then close and clean the Image Buffer and file

    ML_TRACE_IN("MovieCreator::_endRecording()")
  
  if (_numFramesFld->getIntValue() == 0)
  
  {
  
      _messageFld->setStringValue("Empty movie, nothing saved.");
  
  } 
  
  else 
  
  {
  
      _messageFld->setStringValue("Movie written to disk.");
  
      _numFramesFld->setIntValue(0);
  
  if (_hbitmap)
  
  { 
  
      DeleteObject(_hbitmap); 
  
  }
  
  if (c != NULL)
  
  {
  
         av_free(outbuffer);     
  
         av_free(inpic);
  
         av_free(outpic);
  
         fclose(f);
  
         avcodec_close(c);                                                                                               // freeing memory
  
         free(outbuf);
  
         av_free(c);
  
  }
  
  }

  }

  I think the Main Problem is over here !!

                       //out_size = avcodec_encode_video(c, outbuf,outbuf_size, outpic);

• FFmpeg returning an error - What does it mean ?

  19 mars 2013, par user1031947

  I am using FFmpeg, libmp3lame & libx264 along with the node fluent-ffmpeg module. This is my first foray into processing uploaded videos.

  From node, I use the following code to process an uploaded video :

  var proc = new ffmpeg({ source: src, nolog: true })
  
      .usingPreset( "podcast" )
  
      .withAudioCodec( "libmp3lame" )
  
      .saveToFile( dest, function( retcode, err ){
  
           if( err ) throw err;
  
           ...
  
      });

  When I try to process a video, this fails with the following error, which I don't understand. I am hoping someone here can help point me in the right direction. Thanks !

  > ffmpeg version 0.8.5-6:0.8.5-1, Copyright (c) 2000-2012 the Libav
  
  > developers   built on Jan 13 2013 12:05:48 with gcc 4.7.2
  
  > *** THIS PROGRAM IS DEPRECATED *** This program is only provided for compatibility and will be removed in a future release. Please use
  
  > avconv instead.
  
  > 
  
  > Seems stream 0 codec frame rate differs from container frame rate:
  
  > 5994.00 (5994/1) -> 29.97 (2997/100) Input #0, mov,mp4,m4a,3gp,3g2,mj2, from
  
  > '/home/ssp/resources/tmp/32111bf4217e87c23328ec81c56c7d02':  
  
  > Metadata:
  
  >     major_brand     : M4VP
  
  >     minor_version   : 1
  
  >     compatible_brands: M4VPM4A mp42isom
  
  >     creation_time   : 2008-08-26 17:28:47   Duration: 00:00:08.01, start: 0.000000, bitrate: 944 kb/s
  
  >     Stream #0.0(eng): Video: h264 (Constrained Baseline), yuv420p, 480x272, 815 kb/s, 29.97 fps, 29.97 tbr, 2997 tbn, 5994 tbc
  
  >     Metadata:
  
  >       creation_time   : 2008-08-26 17:28:47
  
  >     Stream #0.1(eng): Audio: aac, 44100 Hz, stereo, s16, 124 kb/s
  
  >     Metadata:
  
  >       creation_time   : 2008-08-26 17:28:47 [buffer @ 0xb685a0] w:480 h:272 pixfmt:yuv420p [scale @ 0xb63280] w:480 h:272 fmt:yuv420p ->
  
  > w:320 h:176 fmt:yuv420p flags:0x4 [libx264 @ 0xb67c20] VBV maxrate
  
  > unspecified, assuming CBR [libx264 @ 0xb67c20] using cpu capabilities:
  
  > MMX2 SSE2Fast SSSE3 FastShuffle SSE4.2 AVX [libx264 @ 0xb67c20]
  
  > profile Main, level 1.3 Output #0, m4v, to
  
  > '/home/ssp/resources/users/11/026468c8f4ea1beee0a585ebc2208137.m4v':  
  
  > Metadata:
  
  >     major_brand     : M4VP
  
  >     minor_version   : 1
  
  >     compatible_brands: M4VPM4A mp42isom
  
  >     creation_time   : 2008-08-26 17:28:47
  
  >     encoder         : Lavf53.21.1
  
  >     Stream #0.0(eng): Video: libx264, yuv420p, 320x176, q=10-51, 512 kb/s, 90k tbn, 29.97 tbc
  
  >     Metadata:
  
  >       creation_time   : 2008-08-26 17:28:47
  
  >     Stream #0.1(eng): Audio: libmp3lame, 44100 Hz, 1 channels, s16, 128 kb/s
  
  >     Metadata:
  
  >       creation_time   : 2008-08-26 17:28:47 Stream mapping:   Stream #0.0 -> #0.0   Stream #0.1 -> #0.1 Press ctrl-c to stop encoding frame=  240 fps=154 q=11.0 Lsize=     642kB time=7.97 bitrate=
  
  > 659.3kbits/s     video:516kB audio:126kB global headers:0kB muxing overhead 0.000000% frame I:1     Avg QP:15.35  size:  9995 [libx264 @
  
  > 0xb67c20] frame P:77    Avg QP:13.25  size:  5419 [libx264 @ 0xb67c20]
  
  > frame B:162   Avg QP:18.31  size:   625 [libx264 @ 0xb67c20]
  
  > consecutive B-frames:  2.5% 12.5% 30.0% 55.0% [libx264 @ 0xb67c20] mb
  
  > I  I16..4:  9.1%  0.0% 90.9% [libx264 @ 0xb67c20] mb P  I16..4:  2.1% 
  
  > 0.0%  2.8%  P16..4: 18.0% 29.9% 44.8%  0.0%  0.0%    skip: 2.3% [libx264 @ 0xb67c20] mb B  I16..4:  0.1%  0.0%  0.0%  B16..8: 35.2%
  
  > 20.2%  1.9%  direct:14.5%  skip:28.1%  L0:26.3% L1:38.1% BI:35.6% [libx264 @ 0xb67c20] coded y,uvDC,uvAC intra: 83.7% 91.7% 84.7% inter:
  
  > 27.7% 43.4% 13.9% [libx264 @ 0xb67c20] i16 v,h,dc,p: 20% 29% 42%  9% [libx264 @ 0xb67c20] i4 v,h,dc,ddl,ddr,vr,hd,vl,hu: 17% 29% 20%  4% 
  
  > 8%  6%  9%  3%  4% [libx264 @ 0xb67c20] i8c dc,h,v,p: 60% 19% 16%  5%
  
  > [libx264 @ 0xb67c20] Weighted P-Frames: Y:2.6% UV:0.0% [libx264 @
  
  > 0xb67c20] ref P L0: 75.6% 13.5%  8.0%  2.8%  0.1% [libx264 @ 0xb67c20]
  
  > ref B L0: 94.5%  5.5% [libx264 @ 0xb67c20] kb/s:528.00

• Python SWIG bindings with SomeType ** as function argument

  2 mai 2013, par vericule

  I couldn't find any working Python bindings for ffmpeg, so I decided to generate one with SWIG. Generation was quick and easy (no customization, just default SWIG interface), but these a problem using some functions like int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options); from libavformat/avformat.h. Using C this can be run simply by :

  AVFormatContext *pFormatCtx = NULL;
  
  int status;
  
  status = avformat_open_input(&pFormatCtx, '/path/to/my/file.ext', NULL, NULL);

  In Python I try following :

  >>> from ppmpeg import *
  
  >>> av_register_all()
  
  >>> FormatCtx = AVFormatContext()
  
  >>> FormatCtx
  
   >
  
  >>> avformat_open_input(FormatCtx, '/path/to/my/file.ext', None, None)
  
  Traceback (most recent call last):
  
     File "<stdin>", line 1, in <module>
  
  TypeError: in method &#39;avformat_open_input&#39;, argument 1 of type &#39;AVFormatContext **&#39;
  
  </module></stdin>

  Problem is that Python do not have & equivalent. I tried to use cpointer.i and its pointer_class (%pointer_class(AVFormatContext, new_ctx)), but new_ctx() returns pointer and this is not I want definitely. %pointer_class(AVFormatContext *, new_ctx) is illegal and gives syntax error. I would be grateful for any help. Thanks.

  EDIT :
  I forgot to mention I tried to use typemaps, but don't know how to write custom typemap for struct and documentation has only examples for basic types like int or float...