Jak prawidłowo zwolnić AVCaptureSession

Zamieściłem bardzo podobne pytanie na forum programistów Apple i dostałem odpowiedź od pracownika Apple. Mówi, że to znany problem:

Jest to problem z avcapturesession / VideoDataOutput w iOS 4.0-4.1, który został naprawiony i pojawi się w przyszłej aktualizacji. Na czasu, można obejść go, czekając na krótki okres po zatrzymanie Avcapturessession, np. pół sekundy, przed usunięciem sesja i dane wyjście.

Proponuje następujący kod:

dispatch_after(
    dispatch_time(0, 500000000),
    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), // or main queue, or your own
    ^{
        // Do your work here.
        [session release];
        // etc.
    }
);

Nadal podoba mi się podejście z finalizerem kolejki wysyłkowej, ponieważ ten kod tylko zgaduje, kiedy drugi wątek mógł się skończyć.

Rozwiązane! Być może jest to sekwencja acionów inicjujących sesję. Ten mi działa:

NSError *error = nil;

if(session)
    [session release];

// Create the session
session = [[AVCaptureSession alloc] init];


// Configure the session to produce lower resolution video frames, if your 
// processing algorithm can cope. We'll specify medium quality for the
// chosen device.
session.sessionPreset = AVCaptureSessionPresetMedium;

// Find a suitable AVCaptureDevice
AVCaptureDevice *device = [AVCaptureDevice
                           defaultDeviceWithMediaType:AVMediaTypeVideo];

// Create a device input with the device and add it to the session.
AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device 
                                                                    error:&error];
if (!input) {
    // Handling the error appropriately.
}
[session addInput:input];

// Create a VideoDataOutput and add it to the session
AVCaptureVideoDataOutput *output = [[[AVCaptureVideoDataOutput alloc] init] autorelease];
[session addOutput:output];


// Configure your output.
dispatch_queue_t queue = dispatch_queue_create("myQueue", NULL);
[output setSampleBufferDelegate:self queue:queue];
dispatch_release(queue);

// Specify the pixel format
output.videoSettings = 
[NSDictionary dictionaryWithObject:
 [NSNumber numberWithInt:kCVPixelFormatType_32BGRA] 
                            forKey:(id)kCVPixelBufferPixelFormatTypeKey];

// If you wish to cap the frame rate to a known value, such as 15 fps, set 
// minFrameDuration.
output.minFrameDuration = CMTimeMake(1, 15);

previewLayer = [AVCaptureVideoPreviewLayer layerWithSession:session];
[delegate layerArrived:previewLayer];

NSNotificationCenter *notify =
[NSNotificationCenter defaultCenter];
[notify addObserver: self
            selector: @selector(onVideoError:)
            name: AVCaptureSessionRuntimeErrorNotification
            object: session];
[notify addObserver: self
            selector: @selector(onVideoStart:)
            name: AVCaptureSessionDidStartRunningNotification
            object: session];
[notify addObserver: self
            selector: @selector(onVideoStop:)
            name: AVCaptureSessionDidStopRunningNotification
            object: session];
[notify addObserver: self
            selector: @selector(onVideoStop:)
            name: AVCaptureSessionWasInterruptedNotification
            object: session];
[notify addObserver: self
            selector: @selector(onVideoStart:)
            name: AVCaptureSessionInterruptionEndedNotification
            object: session];

// Start the session running to start the flow of data
[session startRunning];

Btw ta sekwencja chyba rozwiązuje problem synchronicznych powiadomień:)

Z finalizatorami kolejek, możesz użyć dispatch_semaphore dla każdej kolejki, a następnie kontynuować procedurę czyszczenia po zakończeniu.

#define GCD_TIME(delayInSeconds) dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC)

static void vQueueCleanup(void* context) {
  VideoRecordingViewController *vc = (VideoRecordingViewController*)context;
  if (vc.vSema) dispatch_semaphore_signal(vc.vSema);
}

static void aQueueCleanup(void* context) {
  VideoRecordingViewController *vc = (VideoRecordingViewController*)context;
  if (vc.aSema) dispatch_semaphore_signal(vc.aSema);
}

//In your cleanup method:
vSema = dispatch_semaphore_create(0);
aSema = dispatch_semaphore_create(0);
self.avSession = nil;
if (vSema) dispatch_semaphore_wait(vSema, GCD_TIME(0.5));
if (aSema) dispatch_semaphore_wait(aSema, GCD_TIME(0.5));
[self.navigationController popViewControllerAnimated:YES];

Pamiętaj, że musisz ustawić Bufor próbek obiektów AVCaptureVideoDataOutput/AVCaptureAudioDataOutput deleguje na nil, w przeciwnym razie obiekty te nigdy nie zwolnią powiązanych kolejek, a tym samym nigdy nie wywołają finalizatorów po zwolnieniu Avcaptureession.

[avs removeOutput:vOut];
[vOut setSampleBufferDelegate:nil queue:NULL];

 -(void)deallocSession
{
[captureVideoPreviewLayer removeFromSuperlayer];
for(AVCaptureInput *input1 in session.inputs) {
    [session removeInput:input1];
}

for(AVCaptureOutput *output1 in session.outputs) {
    [session removeOutput:output1];
}
[session stopRunning];
session=nil;
outputSettings=nil;
device=nil;
input=nil;
captureVideoPreviewLayer=nil;
stillImageOutput=nil;
self.vImagePreview=nil;

}

Wywołałem tę funkcję, zanim popchnąłem i popchnąłem dowolny inny widok. To rozwiązało mój problem ostrzeżenia o niskiej pamięci.

Zgodnie z aktualnymi dokumentami apple(1) [AVCaptureSession stopRunning] jest operacją synchroniczną, która blokuje się, aż odbiornik całkowicie przestanie działać. Więc wszystkie te problemy nie powinny się już wydarzyć.

Po alokacji Avcapturession możesz użyć:

NSNotificationCenter *notify =
[NSNotificationCenter defaultCenter];
[notify addObserver: self
            selector: @selector(onVideoError:)
            name: AVCaptureSessionRuntimeErrorNotification
            object: session];
[notify addObserver: self
            selector: @selector(onVideoStart:)
            name: AVCaptureSessionDidStartRunningNotification
            object: session];
[notify addObserver: self
            selector: @selector(onVideoStop:)
            name: AVCaptureSessionDidStopRunningNotification
            object: session];
[notify addObserver: self
            selector: @selector(onVideoStop:)
            name: AVCaptureSessionWasInterruptedNotification
            object: session];
[notify addObserver: self
            selector: @selector(onVideoStart:)
            name: AVCaptureSessionInterruptionEndedNotification
            object: session];

Wywołują one odpowiednie metody podczas sesji.stopRunning, session.startRunning itp.

Tam też powinieneś zaimplementować jakiś nieudokumentowany blok oczyszczający:

AVCaptureInput* input = [session.inputs objectAtIndex:0];
[session removeInput:input];
AVCaptureVideoDataOutput* output = (AVCaptureVideoDataOutput*)[session.outputs objectAtIndex:0];
[session removeOutput:output];  

To działa, ale proszę dać mi znać, jeśli widzisz jakąś sztuczkę. Wolałbym pracować z nim asynchronicznie.

Dzięki