Recherche avancée

Sur d’autres sites (6150)

• libavcodec : v4l2 : add support for v4l2 mem2mem codecs

  21 septembre 2017, par Jorge Ramirez-Ortiz

  libavcodec : v4l2 : add support for v4l2 mem2mem codecs
      This patchset enhances Alexis Ballier's original patch and validates
  
      it using Qualcomm's Venus hardware (driver recently landed upstream
  
      [1]).
      This has been tested on Qualcomm's DragonBoard 410c and 820c
  
      Configure/make scripts have been validated on Ubuntu 10.04 and
  
      16.04.
      Tested decoders :
  
             - h264
  
             - h263
  
             - mpeg4
  
             - vp8
  
             - vp9
  
             - hevc
      Tested encoders :
  
             - h264
  
             - h263
  
             - mpeg4
      Tested transcoding (concurrent encoding/decoding)
      Some of the changes introduced :
  
          - v4l2 : code cleanup and abstractions added
  
          - v4l2 : follow the new encode/decode api.
  
          - v4l2 : fix display size for NV12 output pool.
  
          - v4l2 : handle EOS (EPIPE and draining)
  
          - v4l2 : vp8 and mpeg4 decoding and encoding.
  
          - v4l2 : hevc and vp9 support.
  
          - v4l2 : generate EOF on dequeue errors.
  
          - v4l2 : h264_mp4toannexb filtering.
  
          - v4l2 : fixed make install and fate issues.
  
          - v4l2 : codecs enabled/disabled depending on pixfmt defined
  
          - v4l2 : pass timebase/framerate to the context
  
          - v4l2 : runtime decoder reconfiguration.
  
          - v4l2 : add more frame information
  
          - v4l2 : free hardware resources on last reference being released
  
          - v4l2 : encoding : disable b-frames for upstreaming (patch required)
      [1] https://lwn.net/Articles/697956/
      System Level view :
  
          v42l_m2m_enc/dec —> v4l2_m2m —> v4l2_context —> v4l2_buffers
      Reviewed-by : Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
  
      Reviewed-by : Alexis Ballier <aballier@gentoo.org>
  
      Tested-by : Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
  Signed-off-by : wm4 <nfxjfg@googlemail.com>
  

  • [DH] Changelog
  • [DH] configure
  • [DH] libavcodec/Makefile
  • [DH] libavcodec/allcodecs.c
  • [DH] libavcodec/v4l2_buffers.c
  • [DH] libavcodec/v4l2_buffers.h
  • [DH] libavcodec/v4l2_context.c
  • [DH] libavcodec/v4l2_context.h
  • [DH] libavcodec/v4l2_fmt.c
  • [DH] libavcodec/v4l2_fmt.h
  • [DH] libavcodec/v4l2_m2m.c
  • [DH] libavcodec/v4l2_m2m.h
  • [DH] libavcodec/v4l2_m2m_dec.c
  • [DH] libavcodec/v4l2_m2m_enc.c

• Run python ffmpeg audio convertion code file from subprocess.call() within a flask server

  11 novembre 2019, par Kasun

  I have build a small flask server to handle the request. I have 3 parameters in the api function that i want to get. those are type, user_id, audio_file, One is a file. Since it’s used for the audio file conversion. I have to get a file.. I have tested with this in Postman audio file get saved but the subprocess.call(command) in the api function doesn’t work..

  this is the flask server code

  @app.route('/voice', methods=['GET','POST'])
  
  def process_audio():
  
   try:
  
      if request.method == 'POST':
  
          input_type = request.form['type']
  
          user_id = request.form['user_id']
  
          static_file = request.files['audio_file']
  
          audio_name = secure_filename(static_file.filename)
  
          path = 't/'
  
          status = static_file.save(path + audio_name)
  
          full_file = path + audio_name
  
          if input_type == 1:
  
              cmd = "python t/convert_english.py --audio " + full_file
  
              res = subprocess.call([cmd],shell=True)
  
              f = open('t/ress.txt', 'w')
  
              f.write(str(res))
  
              f.close()
  
              return "true"
  
          else:
  
              cmd = "python t/convert_sinhala.py --audio " + full_file
  
              os.system(cmd)
  
              return "true"
  
      else:
  
          return "false"
  
  
  
  except Exception as e:
  
      print(e)
  
      logger.error(e)
  
      return e

  The audio file get saved in the directory as expected..

  this is the convert_english.py

  import subprocess
  
  import argparse
  
  import os
  
  import logging
  
  import speech_recognition as sr
  
  from tqdm import tqdm
  
  from multiprocessing.dummy import Pool
  
  
  
  #subprocess.call('pip install pydub',shell=True)
  
  
  
  from os import path
  
  from pydub import AudioSegment
  
  
  
  logging.basicConfig(filename='/var/www/img-p/t/ee.log', level=logging.DEBUG, 
  
                      format='%(asctime)s %(levelname)s %(name)s %(message)s')
  
  logger=logging.getLogger(__name__)
  
  
  
  ap = argparse.ArgumentParser()
  
  ap.add_argument("-a", "--audio", required=True,
  
      help="path to input audio file")
  
  args = vars(ap.parse_args())
  
  
  
  src = args["audio"]
  
  dst = "audio.wav"
  
  
  
  sound = AudioSegment.from_mp3(src)
  
  sound.export(dst, format="wav")
  
  
  
  #subprocess.call('pip install ffmpeg-python',shell=True)
  
  
  
  subprocess.call('mkdir parts',shell=True)
  
  
  
  subprocess.call('ffmpeg -i audio.wav -f segment -segment_time 30 -c copy parts/out%09d.wav',shell=True)
  
  
  
  #subprocess.call('pip install SpeechRecognition',shell=True)
  
  
  
  
  
  pool = Pool(8) # Number of concurrent threads
  
  
  
  with open("api-key.json") as f:
  
      GOOGLE_CLOUD_SPEECH_CREDENTIALS = f.read()
  
  
  
  r = sr.Recognizer()
  
  files = sorted(os.listdir('parts/'))
  
  
  
  def transcribe(data):
  
      idx, file = data
  
      name = "parts/" + file
  
      print(name + " started")
  
      # Load audio file
  
      with sr.AudioFile(name) as source:
  
          audio = r.record(source)
  
      # Transcribe audio file
  
      text = r.recognize_google_cloud(audio, credentials_json=GOOGLE_CLOUD_SPEECH_CREDENTIALS)
  
      print(name + " done")
  
      return {
  
          "idx": idx,
  
          "text": text
  
      }
  
  
  
  all_text = pool.map(transcribe, enumerate(files))
  
  pool.close()
  
  pool.join()
  
  
  
  transcript = ""
  
  for t in sorted(all_text, key=lambda x: x['idx']):
  
      total_seconds = t['idx'] * 30
  
      # Cool shortcut from:
  
      # https://stackoverflow.com/questions/775049/python-time-seconds-to-hms
  
      # to get hours, minutes and seconds
  
      m, s = divmod(total_seconds, 60)
  
      h, m = divmod(m, 60)
  
  
  
      # Format time as h:m:s - 30 seconds of text
  
      transcript = transcript + "{:0>2d}:{:0>2d}:{:0>2d} {}\n".format(h, m, s, t['text'])
  
  
  
  print(transcript)
  
  
  
  with open("transcript.txt", "w") as f:
  
      f.write(transcript)
  
  
  
  f = open("transcript.txt")
  
  lines = f.readlines()
  
  f.close()
  
  f = open("transcript.txt", "w", encoding="utf-8")
  
  for line in lines:
  
      f.write(line[8:])
  
  f.close()

  The thing is above code works when i manually run the command -> python t/convert_english.py —audio t/tttttttttt.mp3 like this in the terminal..

  But when i try to run from the flask server itself it doesn’t works.. And I’m not getting an error either.

• Render FFmpeg AVFrame as OpenGL texture ?

  5 mars 2019, par ZeroDefect

  I’m attempting to to render a jpeg image (1024x1024 pixels) in the form of an FFmpeg AVFrame as a texture in OpenGL. What I get instead is something that appears as a 1024x1024 dark green quad :

  

  The code to render the AVFrame data in OpenGL is shown below. I have convinced myself that the raw RGB data held within the FFmpeg AVFrame data is not solely dark green.

  GLuint g_texture = {};
  
  
  
  //////////////////////////////////////////////////////////////////////////
  
  void display()
  
  {
  
      // Clear color and depth buffers
  
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
      glMatrixMode(GL_MODELVIEW);     // Operate on model-view matrix
  
  
  
      glEnable(GL_TEXTURE_2D);
  
      GLuint texture = g_texture;
  
      glBindTexture(GL_TEXTURE_2D, texture);
  
  
  
      // Draw a quad
  
      glBegin(GL_QUADS);
  
      glVertex2i(0, 0); // top left
  
      glVertex2i(1024, 0); // top right
  
      glVertex2i(1024, 1024); // bottom right
  
      glVertex2i(0, 1024); // bottom left
  
      glEnd();
  
  
  
      glDisable(GL_TEXTURE_2D);
  
      glBindTexture(GL_TEXTURE_2D, 0);
  
  
  
      glFlush();
  
  }
  
  
  
  /* Initialize OpenGL Graphics */
  
  void initGL(int w, int h)
  
  {
  
      glViewport(0, 0, w, h); // use a screen size of WIDTH x HEIGHT
  
      glEnable(GL_TEXTURE_2D);     // Enable 2D texturing
  
  
  
      glMatrixMode(GL_PROJECTION);     // Make a simple 2D projection on the entire window
  
      glOrtho(0.0, w, h, 0.0, 0.0, 100.0);
  
      glMatrixMode(GL_MODELVIEW);    // Set the matrix mode to object modeling
  
      //glTranslatef( 0, 0, -15 );
  
  
  
      glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  
      glClearDepth(0.0f);
  
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the window
  
  }
  
  
  
  //////////////////////////////////////////////////////////////////////////
  
  int main(int argc, char *argv[])
  
  {
  
      std::shared_ptr<avframe> apAVFrame;
  
      if (!load_image_to_AVFrame(apAVFrame, "marble.jpg"))
  
      {
  
          assert(false);
  
          return 1;
  
      }
  
  
  
      // From here on out, the AVFrame is RGB interleaved
  
      // and is sized to 1,024 x 1,024 (power of 2).
  
  
  
      glutInit(&amp;argc, argv);
  
      glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
  
      glutInitWindowSize(1060, 1060);
  
      glutInitWindowPosition(0, 0);
  
      glutCreateWindow("OpenGL - Creating a texture");
  
  
  
      glGenTextures(1, &amp;g_texture);
  
  
  
      //glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  
      glBindTexture(GL_TEXTURE_2D, g_texture);
  
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, apAVFrame->width,
  
                   apAVFrame->height, 0, GL_RGB, GL_UNSIGNED_BYTE,
  
                   apAVFrame->data[0]);
  
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); /* We will use linear interpolation for magnification filter */
  
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); /* We will use linear interpolation for minifying filter */
  
  
  
      initGL(1060, 1060);
  
  
  
      glutDisplayFunc(display);
  
  
  
      glutMainLoop();
  
  
  
      return 0;
  
  }
  
  </avframe>

  Environment :

  • Ubuntu 18.04
  • GCC v8.2

  EDIT : As per @immibis’ suggestion below, it all works when I change the rendering of the quad to :

  // Draw a quad
  
  glBegin(GL_QUADS);
  
  glTexCoord2f(0, 0);
  
  glVertex2i(0, 0); // top left
  
  glTexCoord2f(1, 0);
  
  glVertex2i(1024, 0); // top right
  
  glTexCoord2f(1, 1);
  
  glVertex2i(1024, 1024); // bottom right
  
  glTexCoord2f(0, 1);
  
  glVertex2i(0, 1024); // bottom left
  
  glEnd();