Recherche avancée

Sur d’autres sites (2190)

• How to access a C pointer array from Golang

  24 avril 2018, par nevernew

  I’m writing an app for the windows platform using FFmpeg and it’s golang wrapper goav, but I’m having trouble understanding how to use the C pointers to gain access to an array.

  I’m trying to get the streams stored in the AVFormatContext class to use in go, and eventually add frames to a texture in OpenGl to make a video player with cool transitions.

  I think understanding how to cast and access the C data will make coding this a lot easier.

  I’ve stripped out all the relevant parts of the C code, the wrapper and my code, shown below :

  C code - libavformat/avformat.h

  typedef struct AVFormatContext { 
  
      unsigned int nb_streams; 
  
      AVStream **streams; 
  
  }

  Golang goav wrapper

  package avutil
  
  
  
  //#cgo pkg-config: libavformat
  
  //#include <libavformat></libavformat>avformat.h>
  
  import "C"
  
  import (
  
      "unsafe"
  
  )
  
  
  
  type Context C.struct_AVFormatContext; 
  
  
  
  func (ctxt *Context) StreamsGet(i uintptr) *Stream {
  
      streams := (**Stream)(unsafe.Pointer(ctxt.streams));
  
      // I think this is where it's going wrong, I'm brand new to this stuff 
  
      return (*Stream)(unsafe.Pointer(uintptr(unsafe.Pointer(streams)) + i*unsafe.Sizeof(*streams)));
  
  }

  My Golang code

  package main
  
  
  
  import "github.com/giorgisio/goav/avformat"
  
  
  
  func main() {
  
      ctx := &avformat.Context{} // the actual function to initiate this does an mallocz for the streams
  
  
  
      stream := ctx.StreamsGet(0)
  
  
  
      //do stuff with stream...
  
  }

  In C it looks like I just have to do just streams[i], but that wont work in go, so I added a function to the wrapper using the technique from my question here.
  However I’m not getting the data ; It looks like I’m getting a pointer to somewhere random in memory. So, how can I access these elements form golang ? Any resources would be helpful too ; I’m going to be investing a fair bit of time into this.

• Make AVI file from H264 compressed data

  6 avril 2017, par vominhtien961476

  I’m using ffmpeg libraries to create a AVI file and following the muxing.c ffmpeg example as below

  1. Allocate the output media context : avformat_alloc_output_context2

  2. Add video streams using the AV_CODEC_ID_H264 codec with below set of parameters :

     int AddVideoStream(AVStream *&video_st, AVFormatContext *&oc, AVCodec **codec, enum AVCodecID codec_id){
     
     
     
     AVCodecContext *c;
     
     
     
     /* find the encoder */
     
     *codec = avcodec_find_encoder(codec_id); //codec id = AV_CODEC_ID_H264
     
     if (!(*codec)) {
     
         sprintf(strError , "Could not find encoder for '%s' line %d\n", avcodec_get_name(codec_id), __LINE__);
     
         commonGlobal->WriteRuntimeBackupLogs(strError);
     
         return RS_NOT_OK;
     
     }
     
     
     
     video_st = avformat_new_stream(oc, *codec);
     
     if (!video_st) {
     
         sprintf(strError , "Could not allocate stream line %d\n", __LINE__);
     
         commonGlobal->WriteRuntimeBackupLogs(strError);
     
         return RS_NOT_OK;
     
     }
     
     video_st->id = oc->nb_streams-1;
     
     c = video_st->codec;
     
     
     
     avcodec_get_context_defaults3(c, *codec);
     
     c->codec_id = codec_id;
     
     
     
     c->bit_rate = 500*1000;
     
     /* Resolution must be a multiple of two. */
     
     c->width    = 1280;
     
     c->height   = 720;
     
     /* timebase: This is the fundamental unit of time (in seconds) in terms
     
     * of which frame timestamps are represented. For fixed-fps content,
     
     * timebase should be 1/framerate and timestamp increments should be
     
     * identical to 1. */
     
     c->time_base.den = 25*1000;
     
     c->time_base.num = 1000;
     
     c->gop_size      = 12;//(int)(av_q2d(c->time_base) / 2);    // GOP size is framerate/2 
     
     c->pix_fmt       = STREAM_PIX_FMT;
     
     /* Some formats want stream headers to be separate. */
     
     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
     
         c->flags |= CODEC_FLAG_GLOBAL_HEADER;
     
     
     
     return RS_OK;

  3. Open Video stream : open_video

     int open_video( AVFormatContext *oc, AVCodec *codec, AVStream *st ){

     int ret;
     
     AVCodecContext *c = st->codec;
     
     char strError[STR_LENGTH_256];
     
     /* open the codec */
     
     ret = avcodec_open2(c, codec, NULL);
     
     if (ret < 0) {
     
         sprintf(strError , "Could not open video codec line %d", __LINE__);
     
         commonGlobal->WriteRuntimeBackupLogs(strError);
     
         return RS_NOT_OK;
     
     }
     
     
     
     /* allocate and init a re-usable frame */
     
     frame = avcodec_alloc_frame();
     
     if (!frame) {
     
         sprintf(strError , "Could not allocate video frame line %d", __LINE__);
     
         commonGlobal->WriteRuntimeBackupLogs(strError);
     
         return RS_NOT_OK;
     
     }
     
     
     
     /* Allocate the encoded raw picture. */
     
     ret = avpicture_alloc(&dst_picture, c->pix_fmt, c->width, c->height);
     
     if (ret < 0) {
     
         sprintf(strError , "Could not allocate picture line %d", __LINE__);
     
         commonGlobal->WriteRuntimeBackupLogs(strError);
     
         return RS_NOT_OK;
     
     }
     
     
     
     /* If the output format is not YUV420P, then a temporary YUV420P
     
     * picture is needed too. It is then converted to the required
     
     * output format. */
     
     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
     
         ret = avpicture_alloc(&src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
     
         if (ret < 0) {
     
             sprintf(strError , "Could not allocate temporary picture line %d", __LINE__);
     
             commonGlobal->WriteRuntimeBackupLogs(strError);
     
             return RS_NOT_OK;
     
         }
     
     }
     
     
     
     /* copy data and linesize picture pointers to frame */
     
     *((AVPicture *)frame) = dst_picture;
     
     return RS_OK;

  4. Write AVI stream header : avformat_write_header

  5. Encode video frame :avcodec_encode_video2

     Case a : The input here are BRG frames so I encode them to H264 and pass to the next step.

     Case b : The input here are H264 compressed frames (these frames captured from H264 RTP stream) so I leave this step then move to next step.

  6. Write Interleave Video frame : av_interleaved_write_frame(oc, &pkt)

     Case a : Writing the packet data encoded from step 5 correctly without error.

     Case b : I Always get error from av_interleaved_write_frame with value -22. It could be EINVAL invalid argument. So someone can tell me what is wrong ? or Some parameters I was missing here.

     int WriteVideoFrame(AVFormatContext *&oc, AVStream *&st, 
     
     uint8_t *imageData `/*BRG data input*/`, 
     
     int width, 
     
     int height, 
     
     bool isStart, 
     
     bool isData,
     
     bool isCompressed, 
     
     AVPacket* packet `/*H264 data input*/`)

     if (isCompressed == false)// For BRG data
     

     static struct SwsContext *sws_ctx;
     
     AVCodecContext *c = st->codec;
     
     
     
     if (isData)
     
     {
     
         if (!frame) {
     
             //fprintf(stderr, "Could not allocate video frame\n");
     
             return RS_NOT_OK;
     
         }
     
         if (isStart == true)
     
             frame->pts = 0;
     
         /* Allocate the encoded raw picture. */
     
         if (width != c->width || height != c->height)
     
         {
     
             if (!sws_ctx)
     
             {
     
                 sws_ctx = sws_getContext(width, height,
     
                     AV_PIX_FMT_BGR24, c->width, c->height,
     
                     AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR, 0, 0, 0);
     
     
     
                 if (!sws_ctx)
     
                 {
     
                     sprintf(strError, "Could not initialize the conversion context line %d\n", __LINE__);
     
                     commonGlobal->WriteRuntimeBackupLogs(strError);
     
                     return RS_NOT_OK;
     
                 }
     
             }
     
             uint8_t * inData[1] = { imageData }; // RGB24 have one plane
     
             int inLinesize[1] = { 3 * width }; // RGB stride
     
             sws_scale(sws_ctx, inData, inLinesize, 0, height, dst_picture.data, dst_picture.linesize);
     
         }
     
         else
     
             BRG24ToYUV420p(dst_picture.data, imageData, width, height); //Phong Le changed this
     
     }
     
     if (oc->oformat->flags & AVFMT_RAWPICTURE)
     
     {
     
         /* Raw video case - directly store the picture in the packet */
     
         AVPacket pkt;
     
         av_init_packet(&pkt);
     
     
     
         pkt.flags |= AV_PKT_FLAG_KEY;
     
         pkt.stream_index = st->index;
     
         pkt.data = dst_picture.data[0];
     
         pkt.size = sizeof(AVPicture);
     
     
     
         ret = av_interleaved_write_frame(oc, &pkt);
     
         av_free_packet(&pkt);
     
     }
     
     else
     
     {
     
         /* encode the image */
     
         AVPacket pkt;
     
         int got_output;
     
     
     
         av_init_packet(&pkt);
     
         pkt.data = NULL;    // packet data will be allocated by the encoder
     
         pkt.size = 0;
     
         ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
     
         if (ret < 0) {
     
             sprintf(strError, "Error encoding video frame line %d\n", __LINE__);
     
             commonGlobal->WriteRuntimeBackupLogs(strError);
     
             av_free_packet(&pkt);
     
             return RS_NOT_OK;
     
         }
     
     
     
         /* If size is zero, it means the image was buffered. */
     
         if (got_output) {
     
             if (c->coded_frame->key_frame)
     
                 pkt.flags |= AV_PKT_FLAG_KEY;
     
     
     
             pkt.stream_index = st->index;
     
     
     
             /* Write the compressed frame to the media file. */
     
             ret = av_interleaved_write_frame(oc, &pkt);
     
         }
     
         else
     
         {
     
             ret = 0;
     
         }
     
         av_free_packet(&pkt);
     
     }
     
     if (ret != 0)
     
     {
     
         sprintf(strError, "Error while writing video frame line %d\n", __LINE__);
     
         commonGlobal->WriteRuntimeBackupLogs(strError);
     
         return RS_NOT_OK;
     
     }
     
     frame->pts += av_rescale_q(1, st->codec->time_base, st->time_base);
     
     return RS_OK;

     else /H264 data/

     if (isStart == true)
     
         packet->pts = 0;
     
     
     
     else
     
         packet->pts += av_rescale_q(1, st->codec->time_base, st->time_base);
     
     
     
     ret = av_interleaved_write_frame(oc, packet);
     
     if (ret < 0)
     
     {
     
         sprintf(strError, "Error while writing video frame line %d\n", __LINE__);
     
         commonGlobal->WriteRuntimeBackupLogs(strError);
     
         return RS_NOT_OK;
     
     }
     
     
     
     return RS_OK;

  7. Close file.

  -> Case a : Creating AVI file successful.

  -> Case b : Fail.

  Thanks
  Tien Vo

• 2 GB Should Be Enough For Me

  31 août 2010, par Multimedia Mike — General

  My new EeePC 1201PN netbook has 2 GB of RAM. Call me shortsighted but I feel like “that ought to be enough for me”. I’m not trying to claim that it ought to be enough for everyone. I am, however, questioning the utility of swap space for those skilled in the art of computing.

  
  
  Technology marches on : This ancient 128 MB RAM module is larger than my digital camera’s battery charger… and I just realized that comparison doesn’t make any sense
  

  Does anyone else have this issue ? It has gotten to the point where I deliberately disable swap partitions on Linux desktops I’m using ('swapoff -a'), and try not to allocate a swap partition during install time. I’m encountering Linux installers that seem to be making it tougher to do this, essentially pleading with you to create a swap partition– “Seriously, you might need 8 total gigabytes of virtual memory one day.” I’m of the opinion that if 2 GB of physical memory isn’t enough for my normal operation, I might need to re-examine my processes.

  In the course of my normal computer usage (which is definitely not normal by the standard of a normal computer user), swap space is just another way for the software to screw things up behind the scenes. In this case, the mistake is performance-related as the software makes poor decisions about what needs to be kept in RAM.

  And then there are the netbook-oriented Linux distributions that insisted upon setting aside as swap 1/2 gigabyte of the already constrained 4 gigabytes of my Eee PC 701′s on-board flash memory, never offering the choice to opt out of swap space during installation. Earmarking flash memory for swap space is generally regarded as exceptionally poor form. To be fair, I don’t know that SSD has been all that prevalent in netbooks since the very earliest units in the netbook epoch.

  Am I alone in this ? Does anyone else prefer to keep all of their memory physical in this day and age ?