Recherche avancée

Sur d’autres sites (8312)

• libav works with RTP stream on PC, but not on Android (Same RTP stream)

  25 septembre 2016, par Nitay

  I’m using libav to decode video received from a 3rd party. The video is received in an Android app and is then made into an RTP stream and published to another device.

  When I use the PC as the target device, the stream decodes properly and I see video. When I use android (same code, compiled to android) the video does not decode at all.
  This happens only with the video from the 3rd party. Other video streams works okay both on PC and on Android.

  To be clear :

  • If stream is casted from a command line using ffmpeg -> Video is displayed both on Android & on PC
  • If stream is casted from the Android App -> Video is displayed only on PC (the same code, compiled for different platforms)

  libav 11.7 was compiled to android using the following line on configure :

  NDK=/opt/android-ndk-r12b
  
  SYSROOT="${NDK}/platforms/android-23/arch-arm/"
  
  ECFLAGS="-march=armv7-a -mfloat-abi=softfp -I /usr/local/include"
  
  ELDFLAGS="-Wl,--fix-cortex-a8 -L /usr/local/lib"
  
  ARCH_SPECIFIC="--disable-asm --arch=arm --cpu=armv7-a --cross-prefix=/opt/android-ndk-r12b/prebuilt/linux-x86_64/bin/../../../toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/arm-linux-androideabi-"
  
  
  
  ./configure \
  
   ${ARCH_SPECIFIC} \
  
   --target-os=linux \
  
   --sysroot="$SYSROOT" \
  
   --extra-cflags="$ECFLAGS" \
  
   --extra-ldflags="$ELDFLAGS" \
  
   --enable-shared \
  
   --disable-symver

  (—disabled-asm is unfortunately needed to avoid text-relocations in the compiled library which is not allowed on Android)

  Here are the libav logs from the android side : http://pastebin.com/MDE3N7BD

  The logs starting with LIBAV are libav messaged, the ones without are my own messages wrapped around the libav functions.

  Logs from the PC side : http://pastebin.com/N0Fd18F9

  The loop that reads the frames :

          // If read frame fails (which happens), keep trying
  
          LOG_DEBUG("Before read frame");
  
          while (av_read_frame(formatContext, &packet) >= 0 && !terminate)
  
          {
  
              LOG_DEBUG1("Packet read. Size: %d", packet.size);
  
  
  
              this->DecodeFrame(videoStreamIndex, formatContext->streams[videoStreamIndex]->codec, &packet);
  
  
  
              av_free_packet(&packet);
  
              av_init_packet(&packet);
  
          }

  And here’s the frames decoding code :

  void VideoDecoder::DecodeFrame(int videoStreamIndex, AVCodecContext* streamCodec, AVPacket* packet)
  
  {
  
      static bool save_file = false;
  
  
  
      AVPixelFormat destinationFormat = AV_PIX_FMT_RGBA;
  
      LOG_DEBUG("Decoding frame!");
  
  
  
  
  
      if (this->isFirstFrame)
  
      {
  
          LOG_DEBUG("Creating codecs");
  
          this->isFirstFrame = false;
  
          // For parsing the packets, we first need to create the right codec
  
          AVCodec* h264Codec = NULL;
  
          // (I'm not sure about why does ffmpeg need this. It has an SDP file which states exactly that, but okay)
  
          h264Codec = avcodec_find_decoder(AV_CODEC_ID_H264);
  
  
  
          // Now make a copy of the codec for us to change
  
          codecContext = avcodec_alloc_context3(h264Codec);
  
          avcodec_get_context_defaults3(codecContext, h264Codec);
  
          avcodec_copy_context(codecContext, streamCodec);
  
  
  
  
  
          // Initialize codecContext to use codec
  
          if (avcodec_open2(codecContext, h264Codec, NULL) >= 0)
  
          {
  
              // There's a nasty edge case here that we need to handle first
  
              if (streamCodec->width == 0 || streamCodec->height == 0)
  
              {
  
                  // That means that the stream initialized before any packets were sent to it, we can't initialize
  
                  // any buffers without knowing their size. So to tackle this we'll initialize the largest buffer 
  
                  // can think of
  
  
  
                  codecContext->width = MAX_RESOLUTION_WIDTH;
  
                  codecContext->height = MAX_RESOLUTION_HEIGHT;
  
              }
  
  
  
              // Instantiate new buffers
  
              int size = avpicture_get_size(AV_PIX_FMT_YUV420P, codecContext->width, codecContext->height);
  
              originalPic = av_frame_alloc();
  
              originalPicBuffer = (uint8_t*)(av_malloc(size));
  
  
  
              avpicture_fill((AVPicture*)originalPic, originalPicBuffer, AV_PIX_FMT_YUV420P, codecContext->width, codecContext->height);
  
          }
  
  
  
          // Instantiate an output context, for usage in the conversion of the picture
  
          outputFormatContext = avformat_alloc_context();
  
      }
  
  
  
      if ((packet->stream_index == videoStreamIndex) && !terminate)
  
      {
  
          // Packet is video. Convert!
  
  
  
          if (outputStream == NULL)
  
          {
  
              //create stream in file
  
              outputStream = avformat_new_stream(outputFormatContext, streamCodec->codec);
  
              avcodec_copy_context(outputStream->codec, streamCodec);
  
              outputStream->sample_aspect_ratio = streamCodec->sample_aspect_ratio;
  
          }
  
  
  
          int pictureReceived = 0;
  
          packet->stream_index = outputStream->id;
  
          int result = avcodec_decode_video2(codecContext, originalPic, &pictureReceived, packet);
  
          //          std::cout << "Bytes decoded " << result << " check " << check << std::endl;
  
  
  
          if (pictureReceived)
  
          {
  
              LOG_DEBUG("New frame received");
  
              // NOTICE: It is generally not a good practice to allocate on demand instead on initialization.
  
              // It this case the edge cases demand it (what happens if width==0 on the first packet?)
  
              if (this->imageConvertContext == NULL)
  
              {
  
                  // Allocate pictures and buffers for conversion
  
                  this->imageConvertContext = sws_getContext(
  
                      codecContext->width,
  
                      codecContext->height,
  
                      codecContext->pix_fmt,
  
                      codecContext->width,
  
                      codecContext->height,
  
                      destinationFormat,
  
                      SWS_BICUBIC,
  
                      NULL, NULL, NULL);
  
              }
  
  
  
              if (this->convertedPic == NULL)
  
              {
  
                  int size_rgba = avpicture_get_size(destinationFormat, codecContext->width, codecContext->height);
  
                  convertedPicBuffer = (uint8_t*)(av_malloc(size_rgba));
  
                  convertedPic = av_frame_alloc();
  
                  avpicture_fill((AVPicture*)convertedPic, convertedPicBuffer, destinationFormat, codecContext->width, codecContext->height);
  
              }
  
  
  
              // Scale the image
  
              sws_scale(imageConvertContext, originalPic->data, originalPic->linesize, 0, codecContext->height, convertedPic->data, convertedPic->linesize);
  
  
  
              // We have a frame! Callback
  
              if (frameReadyCallback != NULL)
  
              {
  
                  LOG_DEBUG3("Updated frame [width=%d, height=%d, ptr=0x%08x]", codecContext->width, codecContext->height, convertedPic->data[0]);
  
                  if (save_file)
  
                  {
  
                      save_file = false;
  
                      std::string filename = "/storage/emulated/0/DCIM/saved_file.rgba";
  
                      save_buffer_to_file((unsigned char*)convertedPic->data[0], codecContext->width * codecContext->height * 4, filename.c_str());
  
                      LOG_DEBUG("Exported file");
  
                  }
  
                  frameReadyCallback((char*)convertedPic->data[0], codecContext->width, codecContext->height);
  
              }
  
          }
  
          else
  
          {
  
              LOG_DEBUG("Packet without frame");
  
          }
  
      }
  
  }

  Obviously the stream from the 3rd party is somehow different, and probably from a different encoder. But it works with libav (same version) on PC. What could be the difference on Android causing it to not find the frames ?

• Merge commit 'b3739599bda740ac12d3dde31a331b744df99123'

  23 octobre 2017, par James Almer

  Merge commit 'b3739599bda740ac12d3dde31a331b744df99123'
  * commit 'b3739599bda740ac12d3dde31a331b744df99123' :
  
    lavc : Drop deprecated emu edge functionality
  Merged-by : James Almer <jamrial@gmail.com>
  

  • [DH] fftools/ffmpeg_opt.c
  • [DH] fftools/ffplay.c
  • [DH] libavcodec/avcodec.h
  • [DH] libavcodec/mjpegenc.c
  • [DH] libavcodec/options_table.h
  • [DH] libavcodec/snowenc.c
  • [DH] libavcodec/utils.c
  • [DH] libavcodec/version.h
  • [DH] libavcodec/wmv2dec.c

• How can I resize an image then centralize it with a white background ? Can it be done using php-Imagine library ?

  6 février 2017, par BOBO

  The effect I would like to generate is exactly like the example in
  this StackOverflow thread : (Related Question)

  1.Resize image
  2.Keep proportion
  3.Add or Fill none-image areas with white background

  Here are three examples of this process below :
  1. If original is square no matter 640*640 or 1024*1024, just resize it to target dimension e.g. 480*480 will work.
  

  2. If the original input is vertical rectangular,the output should not be cropped
     and still be centerlized as below (the red dash edge marker is just make it easier to see the background is white and the proportion is kept after image resized to 480*480 px)
     

  3. if the original input is horizontal rectangular, output like below, white background, keeps proportion and image uncroped , thus without losing anything after the image processing.
     

  So after I’ve clarified such a question,
  I would like to know :

  1. Is there a general name of such Custom Image Resize mentioned above ?
  2. would like to know how to achieve it using php image library Imagine ?
     is it doable using php-imagine, or have to switch to another library, e.g imagemagick ?

  P.S. If you would like to achieve the effect either in image-resizing or video resizing, you can use below FFMPEG single-line command.
  (thanks to @Mulvya, yes below code applies both to videos and image formats)

  [run below built-in code in ffmpeg console to achieve the mentioned resize effect]

  [video resize]

  ffmpeg -i "[raw video url or videofile location.mp4]"  -vf "scale=iw*min(480/iw\,480/ih):ih*min(480/iw\,480/ih),pad=480:480:(480-iw)/2:(480-ih)/2:color=white" [save_path_and_filename].mp4  

  [image resize]

  ffmpeg -i "[raw image url or imagefile location.jpg]"  -vf "scale=iw*min(480/iw\,480/ih):ih*min(480/iw\,480/ih),pad=480:480:(480-iw)/2:(480-ih)/2:color=white" [save_path_and_filename].jpg