Avoid hangs in Blocking functions about androidffmpeg HOT 11 CLOSED

+ int player_create_callback(struct Player *player) {
+   static const AVIOInterruptCB int_cb = {interrupt_cb, NULL};
+   player->input_format_ctx->interrupt_callback = int_cb;
+   player->input_format_ctx->interrupt_callback.opaque = player;
+      //Some verification here
+   return 0;
+ }



+ static int interrupt_cb (void *p)
+ {
+    struct Player *player = (struct Player*) p;
+    if(player->exit_called){
+      return 1;
+    }
+   return 0;
+ }

struct Player {
   .....
    int caputre_streams_no;
+  int exit_called;
    int video_stream_no;
   ....

}


void player_stop(struct State * state) {
    int ret;
+   state->player->exit_called = 1;
    pthread_mutex_lock(&state->player->mutex_operation);
    player_stop_without_lock(state);
    pthread_mutex_unlock(&state->player->mutex_operation);
}

int player_set_data_source(struct State *state, const char *file_path,
        AVDictionary *dictionary, int video_stream_no, int audio_stream_no,
        int subtitle_stream_no) { 

....

+ if ((err = player_create_callback(player)) < 0)
+       goto error;

...
}

static int player_ctx_interrupt_callback(void *p) {
    struct Player *player = (struct Player*) p;
    pthread_mutex_lock(&player->mutex_interrupt);
    if (player->interrupt) {
                //Don't forget to unlock
        pthread_mutex_unlock(&player->mutex_interrupt);
        return 1;
    }
    pthread_mutex_unlock(&player->mutex_interrupt);
    return 0;
}

int player_ctx_interrupt_callback(void *p) {
    int ret = 0;
    struct Player *player = (struct Player*) p;
    pthread_mutex_lock(&player->mutex_interrupt);
    if (player->interrupt) {
        // method is interrupt
        ret = 1; // <- no return just assign variable
    }
    pthread_mutex_unlock(&player->mutex_interrupt);
    return ret;
}

void player_stop_without_lock(struct State * state) {
....
    //playing false so we return and don't execute closing procedure
      if (!player->playing)
        return;
....
}

if (!player->playing && !player->setting_data_source)
        return;

void player_stop(struct State * state) {
    int ret;

    struct Player * player = state->player;

    pthread_mutex_lock(&player->mutex_interrupt);
    player->interrupt = TRUE;
    pthread_mutex_unlock(&player->mutex_interrupt);

+   if(!player->input_inited){
+        //If locking thread a minimal block occurs but exits, not sure what to do
+       //pthread_mutex_lock(&player->mutex_operation);
+       player_open_input_free(player);
+       //pthread_mutex_unlock(&player->mutex_operation);
+   }

    else{
        pthread_mutex_lock(&player->mutex_operation);
        player_stop_without_lock(state);
        pthread_mutex_unlock(&player->mutex_operation);
    }
}



int player_set_data_source(){

....

if ((err = player_open_input(player, file_path, dictionary)) < 0)
        goto error;

+ else if (player->interrupt && !player->input_inited)
+       goto error;

...
}