Recherche avancée

Sur d’autres sites (10894)

• failed to read iv from the auxiliary info

  9 décembre 2017, par diS

  Passing encryption key and kid to mp4 muxer to encrypt the dash segments. With ffmpeg command generating dash single file for playback. But when I play using ffplay I see failed to read the IV from auxiliary info

  ffmpeg -y -f mp4 -i SampleVideo_1280x720_20mb.mp4 -map 0:v:0 -c copy -f dash -encryption_scheme cenc-aes-ctr -encryption_key <key> -encryption_kid <kid> -min_seg_duration 4000000 -use_timeline 1 -use_template 1 -single_file 1 ./enc.mpd
  
  
  
  ffplay enc-stream0.m4s -decryption_key <key>
  
  </key></kid></key>

  I get the error

  [mov,mp4,m4a,3gp,3g2,mj2 @ 0x7fa3040008c0] failed to read iv from the
  auxiliary info

  On side note : don not see playback error when single file generated using mp4 muxer alone. Any inputs ? thanks...

• avformat/http: add "Opening" info logging to ff_http_do_new_request

  13 décembre 2017, par Aman Gupta

  avformat/http: add "Opening" info logging to ff_http_do_new_request
  This mimics logging that was added in 53e0d5d7247 for security
  
  purposes.
  Signed-off-by : Aman Gupta <aman@tmm1.net>
  
  Signed-off-by : Michael Niedermayer <michael@niedermayer.cc>
  

  • [DH] libavformat/http.c

• use AVMutableVideoComposition rotate video after ffmpge can't get rotate info

  29 janvier 2018, par ladeng

  before the video is not rotated, I can use FFmpeg command get rotate information, command like this :

   ffprobe -v quiet -print_format json -show_format -show_streams recordVideo.mp4 

  or

  ffmpeg -i recordVideo.mp4.

  when I use AVMutableVideoComposition rotate video, the video lost video rotate information, rotate video simple : RoatetVideoSimpleCode,
  code below :

  -(void)performWithAsset:(AVAsset*)asset complateBlock:(void(^)(void))complateBlock{
  
  AVMutableComposition *mutableComposition;
  
  AVMutableVideoComposition *mutableVideoComposition;
  
  cacheRotateVideoURL = [[NSURL alloc] initFileURLWithPath:[NSString pathWithComponents:@[NSTemporaryDirectory(), kCacheCertVideoRotate]]];
  
  
  
  AVMutableVideoCompositionInstruction *instruction = nil;
  
  AVMutableVideoCompositionLayerInstruction *layerInstruction = nil;
  
  CGAffineTransform t1;
  
  CGAffineTransform t2;
  
  
  
  AVAssetTrack *assetVideoTrack = nil;
  
  AVAssetTrack *assetAudioTrack = nil;
  
  // Check if the asset contains video and audio tracks
  
  if ([[asset tracksWithMediaType:AVMediaTypeVideo] count] != 0) {
  
      assetVideoTrack = [asset tracksWithMediaType:AVMediaTypeVideo][0];
  
  }
  
  if ([[asset tracksWithMediaType:AVMediaTypeAudio] count] != 0) {
  
      assetAudioTrack = [asset tracksWithMediaType:AVMediaTypeAudio][0];
  
  }
  
  
  
  CMTime insertionPoint = kCMTimeZero;
  
  NSError *error = nil;
  
  
  
  //    CGAffineTransform rotateTranslate;
  
  // Step 1
  
  // Create a composition with the given asset and insert audio and video tracks into it from the asset
  
  if (!mutableComposition) {
  
  
  
      // Check whether a composition has already been created, i.e, some other tool has already been applied
  
      // Create a new composition
  
      mutableComposition = [AVMutableComposition composition];
  
  
  
      // Insert the video and audio tracks from AVAsset
  
      if (assetVideoTrack != nil) {
  
          AVMutableCompositionTrack *compositionVideoTrack = [mutableComposition addMutableTrackWithMediaType:AVMediaTypeVideo preferredTrackID:kCMPersistentTrackID_Invalid];
  
          [compositionVideoTrack insertTimeRange:CMTimeRangeMake(kCMTimeZero, [asset duration]) ofTrack:assetVideoTrack atTime:insertionPoint error:&error];
  
  
  
      }
  
      if (assetAudioTrack != nil) {
  
          AVMutableCompositionTrack *compositionAudioTrack = [mutableComposition addMutableTrackWithMediaType:AVMediaTypeAudio preferredTrackID:kCMPersistentTrackID_Invalid];
  
          [compositionAudioTrack insertTimeRange:CMTimeRangeMake(kCMTimeZero, [asset duration]) ofTrack:assetAudioTrack atTime:insertionPoint error:&error];
  
      }
  
  
  
  }
  
  
  
  
  
  // Step 2
  
  // Translate the composition to compensate the movement caused by rotation (since rotation would cause it to move out of frame)
  
  //    t1 = CGAffineTransformMakeTranslation(assetVideoTrack.naturalSize.height, 0.0);
  
  // Rotate transformation
  
  //    t2 = CGAffineTransformRotate(t1, degreesToRadians(90.0));
  
  
  
  CGFloat degrees = 90;
  
  //--
  
  if (degrees != 0) {
  
      //        CGAffineTransform mixedTransform;
  
      if(degrees == 90){
  
          //90°
  
          t1 = CGAffineTransformMakeTranslation(assetVideoTrack.naturalSize.height,0.0);
  
          t2 = CGAffineTransformRotate(t1,M_PI_2);
  
      }else if(degrees == 180){
  
          //180°
  
          t1 = CGAffineTransformMakeTranslation(assetVideoTrack.naturalSize.width, assetVideoTrack.naturalSize.height);
  
          t2 = CGAffineTransformRotate(t1,M_PI);
  
      }else if(degrees == 270){
  
          //270°
  
          t1 = CGAffineTransformMakeTranslation(0.0, assetVideoTrack.naturalSize.width);
  
          t2 = CGAffineTransformRotate(t1,M_PI_2*3.0);
  
      }
  
  }
  
  
  
  // Step 3
  
  // Set the appropriate render sizes and rotational transforms
  
  if (!mutableVideoComposition) {
  
  
  
      // Create a new video composition
  
      mutableVideoComposition = [AVMutableVideoComposition videoComposition];
  
      mutableVideoComposition.renderSize = CGSizeMake(assetVideoTrack.naturalSize.height,assetVideoTrack.naturalSize.width);
  
      mutableVideoComposition.frameDuration = CMTimeMake(1, 30);
  
  
  
      // The rotate transform is set on a layer instruction
  
      instruction = [AVMutableVideoCompositionInstruction videoCompositionInstruction];
  
      instruction.timeRange = CMTimeRangeMake(kCMTimeZero, [mutableComposition duration]);
  
      layerInstruction = [AVMutableVideoCompositionLayerInstruction videoCompositionLayerInstructionWithAssetTrack:(mutableComposition.tracks)[0]];
  
      [layerInstruction setTransform:t2 atTime:kCMTimeZero];
  
      //           [layerInstruction setTransform:rotateTranslate atTime:kCMTimeZero];
  
  
  
  } else {
  
  
  
      mutableVideoComposition.renderSize = CGSizeMake(mutableVideoComposition.renderSize.height, mutableVideoComposition.renderSize.width);
  
  
  
      // Extract the existing layer instruction on the mutableVideoComposition
  
      instruction = (mutableVideoComposition.instructions)[0];
  
      layerInstruction = (instruction.layerInstructions)[0];
  
  
  
      // Check if a transform already exists on this layer instruction, this is done to add the current transform on top of previous edits
  
      CGAffineTransform existingTransform;
  
  
  
      if (![layerInstruction getTransformRampForTime:[mutableComposition duration] startTransform:&existingTransform endTransform:NULL timeRange:NULL]) {
  
          [layerInstruction setTransform:t2 atTime:kCMTimeZero];
  
      } else {
  
          // Note: the point of origin for rotation is the upper left corner of the composition, t3 is to compensate for origin
  
          CGAffineTransform t3 = CGAffineTransformMakeTranslation(-1*assetVideoTrack.naturalSize.height/2, 0.0);
  
          CGAffineTransform newTransform = CGAffineTransformConcat(existingTransform, CGAffineTransformConcat(t2, t3));
  
          [layerInstruction setTransform:newTransform atTime:kCMTimeZero];
  
      }
  
  
  
  }
  
  
  
  
  
  // Step 4
  
  // Add the transform instructions to the video composition
  
  instruction.layerInstructions = @[layerInstruction];
  
  mutableVideoComposition.instructions = @[instruction];
  
  
  
  //write video
  
  if ([[NSFileManager  defaultManager] fileExistsAtPath:cacheRotateVideoURL.path]) {
  
      NSError *error = nil;
  
      BOOL removeFlag = [[NSFileManager  defaultManager] removeItemAtURL:cacheRotateVideoURL error:&error];
  
      SPLog(@"remove rotate file:%@ %@",cacheRotateVideoURL.path,removeFlag?@"Success":@"Failed");
  
  }
  
  
  
  AVAssetExportSession *exportSession = [[AVAssetExportSession alloc] initWithAsset:asset presetName:AVAssetExportPresetMediumQuality] ;
  
  
  
  exportSession.outputURL = cacheRotateVideoURL;
  
  exportSession.outputFileType = AVFileTypeMPEG4;
  
  exportSession.videoComposition = mutableVideoComposition;
  
  exportSession.shouldOptimizeForNetworkUse = YES;
  
  exportSession.timeRange = CMTimeRangeMake(kCMTimeZero, asset.duration);
  
  
  
  [exportSession exportAsynchronouslyWithCompletionHandler:^{
  
      SPLog(@"cache write done");
  
      AVAsset* asset = [AVURLAsset URLAssetWithURL: cacheRotateVideoURL options:nil];
  
      SPLog(@"rotate recrod video time: %lf",CMTimeGetSeconds(asset.duration));
  
  
  
      ALAssetsLibrary *library = [[ALAssetsLibrary alloc] init];
  
      [library writeVideoAtPathToSavedPhotosAlbum:cacheRotateVideoURL
  
                                  completionBlock:^(NSURL *assetURL, NSError *error) {
  
                                      if (error) {
  
                                          NSLog(@"Save video fail:%@",error);
  
                                      } else {
  
                                          NSLog(@"Save video succeed.");
  
                                      }
  
                                  }];
  
  
  
      complateBlock();
  
  }];

  }

  can anyone tell me why this is so？
  how can I write rotate information when I rotate the video ?