/* void *arg is a argumentReceivingThread_t type */ void receivingThread( void *arg ) { TRACE_2( SERVER , "receivingThread()"); char buff[BUFF_SIZE]; char input[] = "rdb_remote~>"; int ret; void *cliRet; argumentReceivingThread_t *arguments = ( argumentReceivingThread_t * )arg; TRACE_3( SERVER , "Thread argument: socket: %d , port: %d" , arguments->socket , arguments->port ); TRACE_1( SERVER , "[!]Receiving thread create !"); if( arguments->port == PORT_CLI ) sendVoidSocket( arguments->socket , input , sizeof( input ) ); else TRACE_1( SERVER , "Port not used at the moment.\n"); while( 1 ) { memset( buff , 0 , BUFF_SIZE ); ret = recv( arguments->socket , buff , BUFF_SIZE , 0 ); if( ret > 0 ) { if( arguments->port == PORT_CLI ) { TRACE_3( SERVER , "[+]Data: %s" , buff ); cliRet = doCommand( buff ); if( cliRet != NULL ) { sendVoidSocket( arguments->socket , cliRet , strlen( ( const char * )cliRet ) ); zfree( cliRet ); // sendVoidSocket( arguments->socket , input , sizeof( input ) ); } } } } TRACE_3( SERVER , "[!]Quitting receiving thread !"); releaseThread(); pthread_exit( NULL ); }
// ----------------------------------------------------------------------------- // CXIMPSrvSessionAdapter::ServiceError() // ----------------------------------------------------------------------------- // EXPORT_C void CXIMPSrvSessionAdapter::ServiceError( const RMessage2& /*aMessage*/, TInt aError ) { //If assert below is triggered, it means that current message ownersip //is taken somewhere (to be completed asynchronously), but there has //happened a leave after ownership transfer //The place taking message ownership has to be fixed in this case //not to cause exeptions after ownership transfer __ASSERT_ALWAYS( iCurrentMsg, User::Panic( NXIMPPrivPanic::KCategory, NXIMPPrivPanic::ECurrentMsgNotFoundInServiceError ) ); //If assert below is triggered, it means that current message is already //completed, but there has happened a leave after completion //The place completing message has to be fixed in this case //not to cause exeptions after message completion __ASSERT_ALWAYS( !iCurrentMsg->IsCompleted(), User::Panic( NXIMPPrivPanic::KCategory, NXIMPPrivPanic::ECurrentMsgNotValidInServiceError ) ); TRACE_3( _L("CXIMPSrvSessionAdapter[%d]::ServiceError() in op[%d], code[%d]"), this, iCurrentMsg->Function(), aError ); iCurrentMsg->Complete( aError ); delete iCurrentMsg; iCurrentMsg = NULL; }
/** * Send discarded notifications to a lib which will be received by the * saNtfDiscarded callback function. * * @param discardedInfo struct that contains a list of notification id's for * the notifications to be discarded. * * @return return value = 1 if ok -1 if failed */ int send_discard_notification_lib(ntfsv_discarded_info_t *discardedInfo, uns32 c_id, SaNtfSubscriptionIdT s_id, MDS_DEST mds_dest) { uns32 rc = NCSCC_RC_SUCCESS; ntfsv_msg_t msg; TRACE_ENTER(); #if DISCARDED_TEST /* TODO REMOVE TEST */ if ((disc_test_cntr % 20)) { TRACE_3("FAKE DISKARDED"); return NCSCC_RC_FAILURE; } /* END TODO REMOVE TEST */ #endif memset(&msg, 0, sizeof(ntfsv_msg_t)); msg.type = NTFSV_NTFS_CBK_MSG; msg.info.cbk_info.type = NTFSV_DISCARDED_CALLBACK; msg.info.cbk_info.ntfs_client_id = c_id; msg.info.cbk_info.subscriptionId = s_id; msg.info.cbk_info.param.discarded_cbk.notificationType = discardedInfo->notificationType; msg.info.cbk_info.param.discarded_cbk.numberDiscarded = discardedInfo->numberDiscarded; msg.info.cbk_info.param.discarded_cbk.discardedNotificationIdentifiers = discardedInfo->discardedNotificationIdentifiers; rc = ntfs_mds_msg_send(ntfs_cb, &msg, &mds_dest, NULL, /* send regular msg */ MDS_SEND_PRIORITY_HIGH); if (rc != NCSCC_RC_SUCCESS) { TRACE_1("ntfs_mds_msg_send to ntfa failed rc: %d", (int)rc); } else { sendNotConfirmUpdate(c_id, s_id, 0, NTFS_NOTIFICATION_DISCARDED_LIST_SENT); } TRACE_LEAVE(); return (rc); }
void *doCommand( char *cmd ) { TRACE_2( CLI , "doCommand( %s )." , cmd ); int i = 0; int idFuncptr; void *ret = NULL; char *ptr = NULL; /* Dynamic allocation, because after send the response throught the socket, free() is called. (If it's declare like -char errorMsg[]="zedze"- this will crash for sure.) */ char *errorMsg = NULL; ptr = strtok( cmd , " "); env->arg_count = 0; for( i = 0 ; i < MAX_GENERIC_VAL ; i++ ) { ptr = strtok( NULL , " " ); if( !ptr ) break; env->genericVal[i] = ptr; env->arg_count++; } if( env->arg_count > 0 ) { /* Remove '\n' character from the last argument */ ptr = env->genericVal[env->arg_count - 1]; *( ptr + strlen( ptr ) - 1 ) = 0; } if( ( idFuncptr = searchCliCmd( cmd ) ) >= 0 ) { TRACE_3( CLI , "Execute function."); ret = ( void * )cliCmd[idFuncptr].func( env ); TRACE_1( CLI , "Function return: %d" , ret ); } else { TRACE_ERROR( CLI , "Command is not supported."); errorMsg = ( char * )zmalloc( 28 * sizeof( char ) ); memset( errorMsg , 0 , 28 ); sprintf( errorMsg , "Command is not supported.\n"); ret = ( void * )errorMsg; } return ret; }
/**************************************************************************** Name : ava_hdl_cbk_dispatch_one Description : This routine dispatches one pending callback. Arguments : cb - ptr to the AvA control block hdl_rec - ptr to the handle record Return Values : SA_AIS_OK/SA_AIS_ERR_<CODE> Notes : None. ******************************************************************************/ uint32_t ava_hdl_cbk_dispatch_one(AVA_CB **cb, AVA_HDL_REC **hdl_rec) { AVA_PEND_RESP *list_resp = &(*hdl_rec)->pend_resp; AVA_PEND_CBK_REC *rec = 0; uint32_t hdl = (*hdl_rec)->hdl; SaAmfCallbacksT reg_cbk; uint32_t rc = SA_AIS_OK; TRACE_ENTER(); memset(®_cbk, 0, sizeof(SaAmfCallbacksT)); memcpy(®_cbk, &(*hdl_rec)->reg_cbk, sizeof(SaAmfCallbacksT)); /* pop the rec from the mailbox queue */ rec = (AVA_PEND_CBK_REC *)m_NCS_IPC_NON_BLK_RECEIVE(&(*hdl_rec)->callbk_mbx, NULL); if (rec) { if (rec->cbk_info->type != AVSV_AMF_PG_TRACK) { /* push this record into pending response list */ m_AVA_HDL_PEND_RESP_PUSH(list_resp, (AVA_PEND_RESP_REC *)rec); m_AVA_HDL_CBK_REC_IN_DISPATCH_SET(rec); } /* release the cb lock & return the hdls to the hdl-mngr */ m_NCS_UNLOCK(&(*cb)->lock, NCS_LOCK_WRITE); ncshm_give_hdl(hdl); /* process the callback list record */ ava_hdl_cbk_rec_prc(rec->cbk_info, ®_cbk); m_NCS_LOCK(&(*cb)->lock, NCS_LOCK_WRITE); if (0 == (*hdl_rec = ncshm_take_hdl(NCS_SERVICE_ID_AVA, hdl))) { /* hdl is already finalized */ ava_hdl_cbk_rec_del(rec); TRACE_LEAVE2("Handle is already finalized"); return rc; } /* if we are done with this rec, free it */ if ((rec->cbk_info->type != AVSV_AMF_PG_TRACK) && m_AVA_HDL_IS_CBK_RESP_DONE(rec)) { m_AVA_HDL_PEND_RESP_POP(list_resp, rec, rec->cbk_info->inv); ava_hdl_cbk_rec_del(rec); } else if (rec->cbk_info->type == AVSV_AMF_PG_TRACK) { /* PG Track cbk do not have any response */ ava_hdl_cbk_rec_del(rec); } else { m_AVA_HDL_CBK_REC_IN_DISPATCH_RESET(rec); } } else TRACE_3("No record to process the dispatch()"); TRACE_LEAVE(); return rc; }
void end_of_track( sp_session *session ) { TRACE_2( PLAYERMANAGER , "end_of_track()."); TRACE_3( PLAYERMANAGER , "End of track..."); // LOCK_MUTEX( PLAYERMANAGER , &mutexSession ); TRACE_3( PLAYERMANAGER , "Removing the track which have been played."); sp_track_release( currentTrack ); // UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession ); // if( hasNextTrack() == TRUE ) // { // TRACE_1( PLAYERMANAGER , "Load next music !"); // playMusic( session , "" , currentStreamName ); // } if( nextTrackInStream( currentStreamName ) == PC_SUCCESS ) { TRACE_1( PLAYERMANAGER , "Load next music !"); } else { TRACE_WARNING( PLAYERMANAGER , "No more music in the mainplaylist"); audio_fifo_flush( &g_audiofifo ); LOCK_MUTEX( PLAYERMANAGER , &mutexSession ); sp_session_player_play( session , 0 ); sp_session_player_unload( session ); UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession ); playing = FALSE; } }
int createTrackFromUri( char *uri , char *name ) { TRACE_2( PLAYERMANAGER , "createTrackFromUri( %s , __track__ )" , uri ); sp_link *link; sp_error error; if( playing == FALSE && hasNextTrack() == FALSE ) createFile( name ); TRACE_1( PLAYERMANAGER , "Creating URI : %s" , uri ); link = sp_link_create_from_string( uri ); if( link == NULL ) { TRACE_ERROR( PLAYERMANAGER , "Fail to create link."); return PC_ERROR; } else { TRACE_1( PLAYERMANAGER , "Success to create link."); } TRACE_3( PLAYERMANAGER , "Construct track..."); currentTrack = sp_link_as_track( link ); if( currentTrack == NULL ) { TRACE_ERROR( PLAYERMANAGER , "Fail to create track."); return PC_ERROR; } else { TRACE_1( PLAYERMANAGER , "Success to create track."); } error = sp_track_add_ref( currentTrack ); if( error != SP_ERROR_OK ) { TRACE_ERROR( PLAYERMANAGER , "Cannot add ref track, reason: %s" , sp_error_message( error ) ); return PC_ERROR; } sp_link_release( link ); running = TRUE; // playing = FALSE; return PC_SUCCESS; }
/** * Sends and receives an unregister message using osaf_secutil * @param evt_type * @param mds_dest * @param version * @param out_evt * @param timeout max time to wait for a response in ms unit * @return 0 - OK, negated errno otherwise */ int mds_auth_server_disconnect(const char *name, MDS_DEST mds_dest, int svc_id, int timeout) { uint32_t rc; uint8_t msg[32]; uint8_t *p = msg; uint32_t sz; int n; sz = ncs_encode_32bit(&p, MDS_UNREGISTER_REQ); sz += ncs_encode_32bit(&p, svc_id); sz += ncs_encode_64bit(&p, mds_dest); n = osaf_auth_server_connect(name, msg, sz, msg, sizeof(msg), timeout); if (n < 0) { TRACE_3("err n:%d", n); rc = NCSCC_RC_FAILURE; goto fail; } else if (n == 0) { TRACE_3("tmo"); rc = NCSCC_RC_REQ_TIMOUT; goto fail; } else if (n == 8) { p = msg; int type = ncs_decode_32bit(&p); if (type != MDS_UNREGISTER_RESP) { TRACE_3("wrong type %d", type); rc = NCSCC_RC_FAILURE; goto fail; } int status = ncs_decode_32bit(&p); TRACE("received type:%d, status:%d", type, status); status == 0 ? (rc = NCSCC_RC_SUCCESS) : (rc = NCSCC_RC_FAILURE); } else { TRACE_3("err n:%d", n); rc = NCSCC_RC_FAILURE; goto fail; } fail: return rc; }
/****************************************************************************** * Utility functions for get_number_of_log_files_hdl */ static int check_oldest(char *line, char *fname_prefix, int fname_prefix_size, int *old_date, int *old_time) { int date, time, c, d; date = time = c = d = 0; int len = 0; char name_format[SA_MAX_NAME_LENGTH]; char time_stamps[] = "_%d_%d_%d_%d.log"; len = strlen(time_stamps); len += fname_prefix_size; strncpy(name_format, fname_prefix, fname_prefix_size); name_format[fname_prefix_size] = '\0'; TRACE_3("fname: %s", name_format); strncat(name_format, time_stamps, SA_MAX_NAME_LENGTH-1); if (sscanf(line, name_format, &date, &time, &c, &d) == 4) { TRACE_3("line: arg1: %d 2: %d 3: %d 4: %d ok", date, time, c, d); if (date < *old_date || *old_date == -1) { *old_date = date; *old_time = time; return 1; } else if ((date == *old_date) && (time < *old_time)) { *old_date = date; *old_time = time; return 1; } } else if (sscanf(line, name_format, &date, &time) == 2) { TRACE_3("line: arg1: %d 2: %d ok", date, time); if (date < *old_date || *old_date == -1) { *old_date = date; *old_time = time; return 1; } else if ((date == *old_date) && (time < *old_time)) { *old_date = date; *old_time = time; return 1; } } else { TRACE_3("no match"); } return 0; }
void Frontend::inlineProcessFct() { for (Process *proc : *(this->elab->getProcesses()) ) { Function *F = proc->getMainFct(); TRACE_3("Parsing Function : " << F->getName().str() << "\n"); bool restartInlining = true; while(restartInlining) { restartInlining = this->inlineForProcessFct(F); } } }
/** * Send notification to a lib which will be received by the * SaNtfNotificationCallbackT function. * * @param dispatchInfo contains all information about the notification. * * @return return value == NCSCC_RC_SUCCESS if ok */ int send_notification_lib(ntfsv_send_not_req_t *dispatchInfo, uns32 client_id, MDS_DEST mds_dest) { uns32 rc = NCSCC_RC_SUCCESS; ntfsv_msg_t msg; SaNtfNotificationHeaderT *header; int discarded = 0; TRACE_ENTER(); ntfsv_get_ntf_header(dispatchInfo, &header); TRACE_3("client id: %u, not_id: %llu", client_id, *header->notificationId); #if DISCARDED_TEST /* TODO REMOVE TEST */ if ((disc_test_cntr % 20)) { TRACE_3("FAKE DISKARDED"); /* Allways confirm if not success notification will be put in discarded list. */ notificationSentConfirmed(client_id, dispatchInfo->subscriptionId, *header->notificationId, NTFS_NOTIFICATION_DISCARDED); return NCSCC_RC_FAILURE; } /* END TODO REMOVE TEST */ #endif memset(&msg, 0, sizeof(ntfsv_msg_t)); msg.type = NTFSV_NTFS_CBK_MSG; msg.info.cbk_info.type = NTFSV_NOTIFICATION_CALLBACK; msg.info.cbk_info.ntfs_client_id = client_id; msg.info.cbk_info.subscriptionId = dispatchInfo->subscriptionId; msg.info.cbk_info.param.notification_cbk = dispatchInfo; rc = ntfs_mds_msg_send(ntfs_cb, &msg, &mds_dest, NULL, /* send regular msg */ MDS_SEND_PRIORITY_HIGH); if (rc != NCSCC_RC_SUCCESS) { discarded = NTFS_NOTIFICATION_DISCARDED; LOG_ER("ntfs_mds_msg_send to ntfa failed rc: %d", (int)rc); } /* Allways confirm if not success notification will be put in discarded list. */ notificationSentConfirmed(client_id, dispatchInfo->subscriptionId, *header->notificationId, discarded); TRACE_LEAVE(); return (rc); };
/*! * \brief parse_ebml_element * \note 'bitstr' pointer is not checked for performance reasons. * * https://matroska.org/technical/specs/index.html * https://matroska.org/technical/specs/rfc/index.html */ int parse_ebml_element(Bitstream_t *bitstr, EbmlElement_t *element) { TRACE_3(MKV, "parse_ebml_element()"); int retcode = SUCCESS; if (element == NULL) { TRACE_ERROR(MKV, "Invalid EbmlElement_t structure!"); retcode = FAILURE; } else { // Set element offset element->offset_start = bitstream_get_absolute_byte_offset(bitstr); // Read element ID { uint32_t ebml_leadingZeroBits = 0; uint32_t ebml_size = 0; while (read_bit(bitstr) == 0 && ebml_leadingZeroBits < 4) ebml_leadingZeroBits++; ebml_size = (ebml_leadingZeroBits + 1) * 7; element->eid_size = (ebml_size + ebml_leadingZeroBits + 1) / 8; element->eid = read_bits_64(bitstr, ebml_size) + pow(2, ebml_size); } // Read element size { uint32_t ebml_leadingZeroBits = 0; uint32_t ebml_size = 0; while (read_bit(bitstr) == 0 && ebml_leadingZeroBits < 8) ebml_leadingZeroBits++; ebml_size = (ebml_leadingZeroBits + 1) * 7; element->size_size = (ebml_size + ebml_leadingZeroBits + 1) / 8; element->size = read_bits_64(bitstr, ebml_size); } // Set end offset element->offset_end = element->offset_start + (element->eid_size + element->size_size + element->size); } return retcode; }
/*! * \brief Read an EBML element size. * \param *bitstr The bitstream to read. * \return The element size. */ uint64_t read_ebml_size(Bitstream_t *bitstr) { uint32_t leadingZeroBits = 0; uint32_t sizeSize = 0; uint64_t sizeValue = 0; while (read_bit(bitstr) == 0 && leadingZeroBits < 8) leadingZeroBits++; sizeSize = (leadingZeroBits + 1) * 7; sizeValue = read_bits_64(bitstr, sizeSize); TRACE_2(MKV, "read_ebml_size()"); TRACE_3(MKV, "- leadingZeroBits = %u", leadingZeroBits); TRACE_2(MKV, "- sizeSize = %u", sizeSize); TRACE_2(MKV, "- sizeValue = %llu", sizeValue); return sizeValue; }
void Frontend::handleConstruct_and_GV() { // Walk through call graph and build intermediate representation std::vector < Function * >*fctStack = new std::vector < Function * >(); for (Process *proc : *(this->elab->getProcesses()) ) { fctStack->push_back(proc->getMainFct()); proc->addUsedFunction(proc->getMainFct()); this->scjit->setCurrentProcess(proc); TRACE_2("Process:" << proc->getName() << "\n"); while (!fctStack->empty()) { Function* F = fctStack->back(); fctStack->pop_back(); TRACE_3("Parsing Function : " << F->getName().str() << "\n"); PRINT_3(F->dump()); this->handleFctConstruct_and_GV(proc, F, fctStack); } } delete fctStack; }
int music_delivery( sp_session *session , const sp_audioformat *format , const void *frames , int num_frames ) { TRACE_2( PLAYERMANAGER , "music_delivery()."); TRACE_3( PLAYERMANAGER , "Playing music...%d" , num_frames ); audio_fifo_t *af = &g_audiofifo; audio_fifo_data_t *afd; size_t s; TRACE_3( PLAYERMANAGER , "###############################################"); TRACE_3( PLAYERMANAGER , "Channels: %d" , format->channels ); TRACE_3( PLAYERMANAGER , "Rate: %d" , format->sample_rate ); TRACE_3( PLAYERMANAGER , "NSamples: %d" , num_frames ); TRACE_3( PLAYERMANAGER , "###############################################"); // audio discontinuity, do nothing if( num_frames == 0 ) { pthread_mutex_unlock( &af->mutex ); return 0; } // buffer one second of audio if( af->qlen > format->sample_rate ) return 0; s = num_frames * sizeof( int16_t ) * format->channels; afd = zmalloc( sizeof( *afd ) + s ); afd->channels = format->channels; afd->rate = format->sample_rate; afd->nsamples = num_frames; memcpy( afd->samples , frames , s ); TAILQ_INSERT_TAIL( &af->q , afd , link ); af->qlen += num_frames; pthread_cond_signal( &af->cond ); pthread_mutex_unlock( &af->mutex ); return num_frames; }
int nextMusic( sp_session *session , char *uri ) { TRACE_2( PLAYERMANAGER , "nextMusic( __session__ , %s )." , uri ); int status = PC_SUCCESS; TRACE_3( PLAYERMANAGER , "Getting next track from the playqueue."); if( hasNextTrack() == TRUE ) { TRACE_1( PLAYERMANAGER , "Playing next track."); // playMusic( g_session , NULL ); } else { TRACE_ERROR( PLAYERMANAGER , "No next track in the playqueue."); status = PC_ERROR; } return status; }
void MiniTraces_info(void) { unsigned i = 0; printf(PID BLD_GREEN "\nMiniTraces_infos()" CLR_RESET " version 0.4\n"); printf(PID "\n* TRACE LEVELS ENABLED:\n"); TRACE_ERROR(MAIN, "ERROR traces enabled\n"); TRACE_WARNING(MAIN, "WARNING traces enabled\n"); TRACE_INFO(MAIN, "INFO traces enabled\n"); TRACE_1(MAIN, "LVL 1 traces enabled\n"); TRACE_2(MAIN, "LVL 2 traces enabled\n"); TRACE_3(MAIN, "LVL 3 traces enabled\n"); printf(PID "\n* TRACE MODULES CONFIGURATION:\n"); for (i = 0; i < trace_module_count; i++) { printf(PID "[%02x][%5s] Trace Mask 0x%X: ", i, trace_modules_table[i].module_name, trace_modules_table[i].module_output_mask); print_trace_levels(trace_modules_table[i].module_output_mask); } }
/*! * \param *dc The current DecodingContext. * \param startIdx docme. * \param endIdx docme. * * Decode the chroma coefficients of the macroblock. There can only be 4x4 block size. * Start by decoding DC coefficients for Cr block, then Cb block. * Then decode 4 AC blocks of Cb and 4 AC blocks of Cr. */ static void residual_chroma(DecodingContext_t *dc, const int startIdx, const int endIdx) { TRACE_INFO(MB, "<> " BLD_GREEN "residual_chroma()\n" CLR_RESET); // Shortcuts Macroblock_t *mb = dc->mb_array[dc->CurrMbAddr]; sps_t *sps = dc->sps_array[dc->pps_array[dc->active_slice->pic_parameter_set_id]->seq_parameter_set_id]; // if (dc->ChromaArrayType == 1 || dc->ChromaArrayType == 2) { int iCbCr = 0; int NumC8x8 = 4 / (sps->SubWidthC * sps->SubHeightC); for (iCbCr = 0; iCbCr < 2; iCbCr++) { if ((mb->CodedBlockPatternChroma & 3) && (startIdx == 0)) { TRACE_2(MB, "---- residual_chroma 4x4 DC (mb %i - iCbCr %i - blk 0) ---------------- START\n", mb->mbAddr, iCbCr); if (dc->entropy_coding_mode_flag) residual_block_cabac(dc, mb->ChromaDCLevel[iCbCr], 0, 4 * NumC8x8 - 1, 4 * NumC8x8, blk_CHROMA_DC_Cb + iCbCr, 0); else residual_block_cavlc(dc, mb->ChromaDCLevel[iCbCr], 0, 4 * NumC8x8 - 1, 4 * NumC8x8, blk_CHROMA_DC_Cb + iCbCr, 0); } else { TRACE_2(MB, "---- residual_chroma 4x4 DC (mb %i - iCbCr %i - blk 0) ---------------- EMPTY\n\n", mb->mbAddr, iCbCr); int i = 0; for (i = 0; i < (4 * NumC8x8); i++) { mb->ChromaDCLevel[iCbCr][i] = 0; } } } for (iCbCr = 0; iCbCr < 2; iCbCr++) { int blkIdx = 0; int i8x8 = 0; for (i8x8 = 0; i8x8 < NumC8x8; i8x8++) { int i4x4 = 0; for (i4x4 = 0; i4x4 < 4; i4x4++) { blkIdx = i8x8*4 + i4x4; if (mb->CodedBlockPatternChroma & 2) { TRACE_2(MB, "---- residual_chroma 4x4 AC (mb %i - iCbCr %i - blk %i/3) ---------------- START\n", mb->mbAddr, iCbCr, blkIdx); if (dc->entropy_coding_mode_flag) residual_block_cabac(dc, mb->ChromaACLevel[iCbCr][blkIdx], MAX(0, startIdx - 1), endIdx - 1, 15, blk_CHROMA_AC_Cb + iCbCr, blkIdx); else residual_block_cavlc(dc, mb->ChromaACLevel[iCbCr][blkIdx], MAX(0, startIdx - 1), endIdx - 1, 15, blk_CHROMA_AC_Cb + iCbCr, blkIdx); } else { TRACE_2(MB, "---- residual_chroma 4x4 AC (mb %i - iCbCr %i - blk %i/3) ---------------- EMPTY\n\n", mb->mbAddr, iCbCr, blkIdx); int i = 0; for (i = 0; i < 15; i++) { mb->ChromaACLevel[iCbCr][blkIdx][i] = 0; } } } } } } TRACE_3(MB, "---- residual_chroma - the end\n\n"); }
/*! * \param *dc The current DecodingContext. * \param startIdx docme. * \param endIdx docme. * * 7.4.5.3.1 Residual luma data semantics. * Output of this syntax structure are the variables i16x16DClevel, i16x16AClevel, level, and level8x8. * * This function decode the luma coefficients contained in a macroblock. It can * handle 16x16 block (composed of one 4x4 DC block and 16 4x4 AC blocks) * 4x4 blocks (16 4x4 blocks) and 8x8 blocks (4 8x8 blocks). */ static void residual_luma(DecodingContext_t *dc, const int startIdx, const int endIdx) { TRACE_INFO(MB, "<> " BLD_GREEN "residual_luma()\n" CLR_RESET); // Shortcut Macroblock_t *mb = dc->mb_array[dc->CurrMbAddr]; // if (startIdx == 0 && mb->MbPartPredMode[0] == Intra_16x16) { TRACE_2(MB, "---- residual_luma 4x4 DC (mb %i - blk 0) ---------------- START - 16x16 DC\n", mb->mbAddr); if (dc->entropy_coding_mode_flag) residual_block_cabac(dc, mb->Intra16x16DCLevel, 0, 15, 16, blk_LUMA_16x16_DC, 0); else residual_block_cavlc(dc, mb->Intra16x16DCLevel, 0, 15, 16, blk_LUMA_16x16_DC, 0); } int blkIdx = 0; int i8x8 = 0; for (i8x8 = 0; i8x8 < 4; i8x8++) { if (mb->transform_size_8x8_flag == false || dc->entropy_coding_mode_flag == false) { int i4x4 = 0; for (i4x4 = 0; i4x4 < 4; i4x4++) { blkIdx = i8x8*4 + i4x4; if (mb->CodedBlockPatternLuma & (1 << i8x8)) { if (mb->MbPartPredMode[0] == Intra_16x16) { TRACE_2(MB, "---- residual_luma 16x16 AC (mb %i - blk %i/15) ---------------- START - 16x16 AC\n", mb->mbAddr, blkIdx); if (dc->entropy_coding_mode_flag) residual_block_cabac(dc, mb->Intra16x16ACLevel[blkIdx], MAX(0, startIdx - 1), endIdx - 1, 15, blk_LUMA_16x16_AC, blkIdx); else residual_block_cavlc(dc, mb->Intra16x16ACLevel[blkIdx], MAX(0, startIdx - 1), endIdx - 1, 15, blk_LUMA_16x16_AC, blkIdx); } else { TRACE_2(MB, "---- residual_luma 4x4 (mb %i - blk %i/15) ---------------- START\n", mb->mbAddr, blkIdx); if (dc->entropy_coding_mode_flag) residual_block_cabac(dc, mb->LumaLevel4x4[blkIdx], startIdx, endIdx, 16, blk_LUMA_4x4, blkIdx); else residual_block_cavlc(dc, mb->LumaLevel4x4[blkIdx], startIdx, endIdx, 16, blk_LUMA_4x4, blkIdx); } } else if (mb->MbPartPredMode[0] == Intra_16x16) { TRACE_2(MB, "---- residual_luma 16x16 AC (mb %i - blk %i/15) ---------------- EMPTY - no 16x16 AC coeff\n\n", mb->mbAddr, blkIdx); int i = 0; for (i = 0; i < 15; i++) { mb->Intra16x16ACLevel[blkIdx][i] = 0; mb->TotalCoeffs_luma[blkIdx] = 0; } } else { TRACE_2(MB, "---- residual_luma 4x4 (mb %i - blk %i/15) ---------------- EMPTY\n\n", mb->mbAddr, blkIdx); int i = 0; for (i = 0; i < 16; i++) { mb->LumaLevel4x4[blkIdx][i] = 0; mb->TotalCoeffs_luma[blkIdx] = 0; } } if (!dc->entropy_coding_mode_flag && mb->transform_size_8x8_flag) { TRACE_2(MB, "---- residual_luma 8x8 from 4x4 (mb %i) ----------------\n\n", mb->mbAddr, blkIdx); int i = 0; for (i = 0; i < 16; i++) { mb->LumaLevel8x8[i8x8][4 * i + i4x4] = mb->LumaLevel4x4[blkIdx][i]; } } } } else if (mb->CodedBlockPatternLuma & (1 << i8x8)) { TRACE_2(MB, "---- residual_luma 8x8 (mb %i - blk %i/3) ---------------- START\n", mb->mbAddr, i8x8); if (dc->entropy_coding_mode_flag) residual_block_cabac(dc, mb->LumaLevel8x8[i8x8], 4 * startIdx, 4 * endIdx + 3, 64, blk_LUMA_8x8, i8x8); else residual_block_cavlc(dc, mb->LumaLevel8x8[i8x8], 4 * startIdx, 4 * endIdx + 3, 64, blk_LUMA_8x8, i8x8); } else { TRACE_2(MB, "---- residual_luma 8x8 (mb %i - blk %i/3) ---------------- EMPTY\n\n", mb->mbAddr, i8x8); int i = 0; for (i = 0; i < 64; i++) { mb->LumaLevel8x8[i8x8][i] = 0; } } } TRACE_3(MB, "---- residual_luma - the end\n\n"); }
int mp3_fileParse(MediaFile_t *media) { int retcode = SUCCESS; TRACE_INFO(MP3, BLD_GREEN "mp3_fileParse()" CLR_RESET); // Init bitstream to parse container infos Bitstream_t *bitstr = init_bitstream(media, NULL); if (bitstr != NULL) { // Init a MediaStream_t to store samples retcode = init_bitstream_map(&media->tracks_audio[0], 0, 999999); // Init an MP3 structure mp3_t mp3; memset(&mp3, 0, sizeof(mp3_t)); // A convenient way to stop the parser mp3.run = true; // stuff int64_t min_frame_size = 128; int64_t frame_offset = 0; uint32_t frame_header = 0; bool first_frame_parsed = false; // Loop on 1st level elements while (mp3.run == true && retcode == SUCCESS && bitstream_get_absolute_byte_offset(bitstr) < (media->file_size - min_frame_size)) { // Seek to the next frame offset // Assume the MP3 frames will not be bigger than 4Gib uint32_t jump_bits = (uint32_t)(frame_offset - bitstream_get_absolute_byte_offset(bitstr)) * 8; if (jump_bits > 0) skip_bits(bitstr, jump_bits); // Read the next frame header frame_header = read_bits(bitstr, 32); // note: check frame header against 11 bits long instead of 12, to be compatible with MPEG-1/2/2.5 if ((frame_header & 0xFFE00000) == 0xFFE00000) { TRACE_1(MP3, "> MP3 frame @ %lli", frame_offset); if (first_frame_parsed == false) { frame_offset = parse_frame_full(bitstr, frame_header, &mp3, media); if (frame_offset > 0) first_frame_parsed = true; else retcode = FAILURE; } else { frame_offset = parse_frame(bitstr, frame_header, &mp3, media); } } else if ((frame_header & 0xFFFFFF00) == 0x54414700) { TRACE_INFO(MP3, "> ID3v1 tag @ %lli", frame_offset); mp3.run = false; // Add the TAG to the track int sid = media->tracks_audio[0]->sample_count; if (sid < 999999) { media->tracks_audio[0]->sample_type[sid] = sample_AUDIO_TAG; media->tracks_audio[0]->sample_size[sid] = media->file_size - frame_offset; media->tracks_audio[0]->sample_offset[sid] = frame_offset; media->tracks_audio[0]->sample_pts[sid] = 0; media->tracks_audio[0]->sample_dts[sid] = 0; media->tracks_audio[0]->sample_count++; } } else if ((frame_header & 0xFFFFFF00) == 0x49443300) { int id3tag_version = ((frame_header & 0x000000FF) << 8) + read_bits(bitstr, 8); /*int id3tag_flag =*/ read_bits(bitstr, 8); TRACE_INFO(MP3, "> ID3v2.%i @ %lli", id3tag_version, frame_offset); uint32_t id3tag_size = read_bits(bitstr, 8) & 0x0000007F; id3tag_size <<= 7; id3tag_size += read_bits(bitstr, 8) & 0x0000007F; id3tag_size <<= 7; id3tag_size += read_bits(bitstr, 8) & 0x0000007F; id3tag_size <<= 7; id3tag_size += read_bits(bitstr, 8) & 0x0000007F; id3tag_size += 10; // bytes already read // Add the TAG to the track int sid = media->tracks_audio[0]->sample_count; if (sid < 999999) { media->tracks_audio[0]->sample_type[sid] = sample_AUDIO_TAG; media->tracks_audio[0]->sample_size[sid] = id3tag_size; media->tracks_audio[0]->sample_offset[sid] = frame_offset; media->tracks_audio[0]->sample_pts[sid] = 0; media->tracks_audio[0]->sample_dts[sid] = 0; media->tracks_audio[0]->sample_count++; } // Simulate TAG parsing frame_offset += id3tag_size; } else if (frame_header == 0x4C595249) { TRACE_INFO(MP3, "> Lyrics3 tag @ %lli", frame_offset); frame_offset += 32; // just restart MP3 frame detection 32 bytes later... // Add the TAG to the track int sid = media->tracks_audio[0]->sample_count; if (sid < 999999) { media->tracks_audio[0]->sample_type[sid] = sample_AUDIO_TAG; media->tracks_audio[0]->sample_size[sid] = 0; media->tracks_audio[0]->sample_offset[sid] = frame_offset; media->tracks_audio[0]->sample_pts[sid] = 0; media->tracks_audio[0]->sample_dts[sid] = 0; media->tracks_audio[0]->sample_count++; } } else if (frame_header == 0x58696E67) { TRACE_INFO(MP3, "> XING tag @ %lli", frame_offset); frame_offset += 32; // just restart MP3 frame detection 32 bytes later... // Add the TAG to the track int sid = media->tracks_audio[0]->sample_count; if (sid < 999999) { media->tracks_audio[0]->sample_type[sid] = sample_AUDIO_TAG; media->tracks_audio[0]->sample_size[sid] = 0; media->tracks_audio[0]->sample_offset[sid] = frame_offset; media->tracks_audio[0]->sample_pts[sid] = 0; media->tracks_audio[0]->sample_dts[sid] = 0; media->tracks_audio[0]->sample_count++; } } else if (frame_header == 0x56425249) { TRACE_INFO(MP3, "> VBRI tag @ %lli", frame_offset); frame_offset += 32; // just restart MP3 frame detection 32 bytes later... // Add the TAG to the track int sid = media->tracks_audio[0]->sample_count; if (sid < 999999) { media->tracks_audio[0]->sample_type[sid] = sample_AUDIO_TAG; media->tracks_audio[0]->sample_size[sid] = 0; media->tracks_audio[0]->sample_offset[sid] = frame_offset; media->tracks_audio[0]->sample_pts[sid] = 0; media->tracks_audio[0]->sample_dts[sid] = 0; media->tracks_audio[0]->sample_count++; } } else if (frame_header == 0x41504554) { TRACE_WARNING(MP3, "> APE tag @ %lli", frame_offset); /*uint32_t apetag_header =*/ read_bits(bitstr, 32); // 0x41474558, second part of the tag header /*uint32_t apetag_version =*/ read_bits(bitstr, 32); uint32_t apetag_size = 8 + read_bits(bitstr, 32); // APE header size (8 bytes) + tag content size // Add the TAG to the track int sid = media->tracks_audio[0]->sample_count; if (sid < 999999) { media->tracks_audio[0]->sample_type[sid] = sample_AUDIO_TAG; media->tracks_audio[0]->sample_size[sid] = apetag_size; media->tracks_audio[0]->sample_offset[sid] = frame_offset; media->tracks_audio[0]->sample_pts[sid] = 0; media->tracks_audio[0]->sample_dts[sid] = 0; media->tracks_audio[0]->sample_count++; } // Simulate TAG parsing frame_offset = frame_offset + apetag_size; } else { // Try to find a new startcode closeby... frame_offset += 1; TRACE_3(MP3, "Unknown frame header @ %lli (startcode: 0x%X)", frame_offset, frame_header); } } if (retcode == SUCCESS) { retcode = mp3_indexer_track(media, &mp3); if (retcode == SUCCESS) { retcode = mp3_indexer(media, &mp3); } } } else { retcode = FAILURE; } return retcode; }
/**************************************************************************** Name : eda_eds_msg_proc Description : This routine is used to process the ASYNC incoming EDS messages. Arguments : pointer to struct ncsmds_callback_info Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None. ******************************************************************************/ static uint32_t eda_eds_msg_proc(EDA_CB *eda_cb, EDSV_MSG *edsv_msg, MDS_SEND_PRIORITY_TYPE prio) { switch (edsv_msg->type) { case EDSV_EDS_CBK_MSG: switch (edsv_msg->info.cbk_info.type) { case EDSV_EDS_CHAN_OPEN: { EDA_CLIENT_HDL_REC *eda_hdl_rec; EDA_CHANNEL_HDL_REC *channel_hdl_rec; EDSV_EDA_CHAN_OPEN_CBK_PARAM *cbk_param = &edsv_msg->info.cbk_info.param.chan_open_cbk; /** Create the chan hdl record here before ** queing this message onto the priority queue ** so that the dispatch by the application to fetch ** the callback is instantaneous. **/ /** Lookup the hdl rec by reg_id **/ if (NULL == (eda_hdl_rec = eda_find_hdl_rec_by_regid(eda_cb, edsv_msg->info.cbk_info. eds_reg_id))) { TRACE_4("client handle record for reg_id: %u not found", edsv_msg->info.cbk_info.eds_reg_id); eda_msg_destroy(edsv_msg); return NCSCC_RC_FAILURE; } /** Create/add a channel record to the hdl rec with ** the information received in this message. ** only if the return status was SA_AIS_OK. **/ if (SA_AIS_OK == cbk_param->error) { if (NULL == (channel_hdl_rec = eda_channel_hdl_rec_add(&eda_hdl_rec, cbk_param->chan_id, cbk_param->chan_open_id, cbk_param-> chan_open_flags, &cbk_param-> chan_name))) { TRACE_4("channel add failed for chan_id: %u, chan_open_id: %u, \ channelname: %s", cbk_param->chan_id, cbk_param->chan_open_id, cbk_param->chan_name.value); eda_msg_destroy(edsv_msg); return NCSCC_RC_FAILURE; } /** pass on the channel_hdl to the application thru cbk **/ cbk_param->eda_chan_hdl = channel_hdl_rec->channel_hdl; } /** enqueue this message anyway **/ if (NCSCC_RC_SUCCESS != m_NCS_IPC_SEND(&eda_hdl_rec->mbx, edsv_msg, prio)) { TRACE_4("IPC send failed failed for msg type: %u", edsv_msg->type); return NCSCC_RC_FAILURE; } } break; case EDSV_EDS_DELIVER_EVENT: { EDA_CLIENT_HDL_REC *eda_hdl_rec; EDA_CHANNEL_HDL_REC *chan_hdl_rec; EDA_EVENT_HDL_REC *evt_hdl_rec; EDSV_EDA_EVT_DELIVER_CBK_PARAM *evt_dlv_param = &edsv_msg->info.cbk_info.param.evt_deliver_cbk; /** Lookup the hdl rec **/ if (NULL == (eda_hdl_rec = eda_find_hdl_rec_by_regid(eda_cb, edsv_msg->info.cbk_info. eds_reg_id))) { TRACE_4("reg record not found reg_id: %u", edsv_msg->info.cbk_info.eds_reg_id); edsv_free_evt_pattern_array(evt_dlv_param->pattern_array); evt_dlv_param->pattern_array = NULL; /** free the event data if any **/ if (evt_dlv_param->data) { m_MMGR_FREE_EDSV_EVENT_DATA(evt_dlv_param->data); evt_dlv_param->data = NULL; } eda_msg_destroy(edsv_msg); return NCSCC_RC_FAILURE; } /** Lookup the channel record to which ** this event belongs **/ if (NULL == (chan_hdl_rec = eda_find_chan_hdl_rec_by_chan_id(eda_hdl_rec, evt_dlv_param->chan_id, evt_dlv_param-> chan_open_id))) { TRACE_4("chan rec not found for chan_id: %u, chan_open_id: %u", evt_dlv_param->chan_id, evt_dlv_param->chan_open_id); edsv_free_evt_pattern_array(evt_dlv_param->pattern_array); evt_dlv_param->pattern_array = NULL; /** free the event data if any **/ if (evt_dlv_param->data) { m_MMGR_FREE_EDSV_EVENT_DATA(evt_dlv_param->data); evt_dlv_param->data = NULL; } eda_msg_destroy(edsv_msg); return NCSCC_RC_FAILURE; } /** Create/Add the new event record. **/ if (NULL == (evt_hdl_rec = eda_event_hdl_rec_add(&chan_hdl_rec))) { edsv_free_evt_pattern_array(evt_dlv_param->pattern_array); evt_dlv_param->pattern_array = NULL; /** free the event data if any **/ if (evt_dlv_param->data) { m_MMGR_FREE_EDSV_EVENT_DATA(evt_dlv_param->data); evt_dlv_param->data = NULL; } eda_msg_destroy(edsv_msg); TRACE_4("event record add failed"); return NCSCC_RC_FAILURE; } /** Initialize the fields in the evt_hdl_rec with data ** received in the message. **/ evt_hdl_rec->priority = evt_dlv_param->priority; evt_hdl_rec->publisher_name = evt_dlv_param->publisher_name; evt_hdl_rec->publish_time = evt_dlv_param->publish_time; evt_hdl_rec->retention_time = evt_dlv_param->retention_time; evt_hdl_rec->event_data_size = evt_dlv_param->data_len; /** mark the event as rcvd. **/ evt_hdl_rec->evt_type |= EDA_EVT_RECEIVED; /** Create/Add the new event inst record. **/ /** The evt hdl rec will take ownership of the memory ** for the patterns & data to avoid too many copies ** and not that much use of these in the callback. **/ evt_hdl_rec->del_evt_id = evt_dlv_param->eda_event_id; evt_hdl_rec->pattern_array = evt_dlv_param->pattern_array; evt_dlv_param->pattern_array = NULL; evt_hdl_rec->evt_data = evt_dlv_param->data; evt_dlv_param->data = NULL; /* assign the newly allocated hdl */ evt_dlv_param->event_hdl = evt_hdl_rec->event_hdl; /** enqueue this message. MDS & IPC priority match 1-1 **/ if (NCSCC_RC_SUCCESS != m_NCS_IPC_SEND(&eda_hdl_rec->mbx, edsv_msg, prio)) { TRACE_4("IPC send failed for msg type: %u", edsv_msg->type); return NCSCC_RC_FAILURE; } } break; case EDSV_EDS_CLMNODE_STATUS: { EDSV_EDA_CLM_STATUS_CBK_PARAM *clm_status_param = &edsv_msg->info.cbk_info.param.clm_status_cbk; eda_cb->node_status = (SaClmClusterChangesT)clm_status_param->node_status; TRACE_1("Local node membership changed to : %u", eda_cb->node_status); } break; default: TRACE_3("unknown message type: %u", edsv_msg->info.cbk_info.type); return NCSCC_RC_FAILURE; break; } break; case EDSV_EDS_MISC_MSG: /** No messages conceived yet **/ TRACE_1("Unsupported message type"); return NCSCC_RC_FAILURE; break; default: /** Unexpected message **/ TRACE_4("Wrong message type"); return NCSCC_RC_FAILURE; break; }
int playMusic( sp_session *session , char *uri , char *name , playqueue_fifo_t *playqueue ) { TRACE_2( PLAYERMANAGER , "playMusic()."); static int firstTime = 0; int status = PC_SUCCESS; char response[255] = { 0 }; sp_error error; LOCK_MUTEX( PLAYERMANAGER , &mutexSession ); TRACE_3( PLAYERMANAGER , "Test if a music is playing or not"); if( currentTrack == NULL ) { TRACE_WARNING( PLAYERMANAGER , "Cannot play track because no track has been loaded."); status = PC_ERROR; snprintf( response , 255 , "NOK: Cannot play track because no track has been loaded."); sendVoid( ( void * )response , strlen( response ) ); } else { TRACE_1( PLAYERMANAGER , "Getting the track."); currentTrack = getNextTrackToPlayqueue( playqueue ); loadTrack( session , currentTrack ); error = sp_session_player_play( session , 1 ); if( error != SP_ERROR_OK ) { TRACE_ERROR( PLAYERMANAGER , "Cannot play track, reason: %s" , sp_error_message( error ) ); status = PC_ERROR; } else { TRACE_1( PLAYERMANAGER , "Success to play track."); if( firstTime++ != 0 ) playStream( name ); playing = TRUE; snprintf( response , 255 , "OK"); sendVoid( ( void * )response , strlen( response ) ); } if( currentStreamName[0] == 0 ) { strncpy( currentStreamName , name , strlen( name ) ); } else if( strcmp( currentStreamName , name ) != 0 ) { memset( currentStreamName , 0 , 255 ); strncpy( currentStreamName , name , strlen( name ) ); } else if( !strcmp( currentStreamName , name ) ) { //Do nothing } } UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession ); return status; }
int createFile( char *name ) { TRACE_2( FILEMANAGER , "createFile( %s )." , name ); FILE *f = NULL; FILE *h = NULL; wavHeader_t wavH; size_t ret; int status = PC_SUCCESS; memset( filename , 0 , 255 ); sprintf( filename , "%s%s.wav" , STREAM_FOLDER , name ); TRACE_INFO( FILEMANAGER , "Creating stream filename : %s." , filename ); f = fopen( filename , "wb+"); h = fopen( REF_FILE , "rb"); if( f == NULL || h == NULL ) { TRACE_ERROR( FILEMANAGER , "f or h FILE is NULL"); status = PC_ERROR; } else { ret = fread( &wavH , sizeof( wavH ) , 1 , h ); if( ret != 1 ) { TRACE_ERROR( FILEMANAGER , "Fail to read all data."); status = PC_ERROR; } else { TRACE_3( FILEMANAGER , "######################################"); TRACE_3( FILEMANAGER , "RIFF: %s" , wavH.RIFF ); TRACE_3( FILEMANAGER , "ChunkSize: %d" , wavH.ChunkSize ); TRACE_3( FILEMANAGER , "WAVE: %s" , wavH.WAVE ); TRACE_3( FILEMANAGER , "fmt: %s" , wavH.fmt ); TRACE_3( FILEMANAGER , "Subchunk1Size: %d" , wavH.Subchunk1Size ); TRACE_3( FILEMANAGER , "AudioFormat: %d" , wavH.AudioFormat ); TRACE_3( FILEMANAGER , "NumOfchan: %d" , wavH.NumOfChan ); TRACE_3( FILEMANAGER , "SamplesPerSec: %d" , wavH.SamplesPerSec ); TRACE_3( FILEMANAGER , "bytesPerSec: %d" , wavH.bytesPerSec ); TRACE_3( FILEMANAGER , "blockAlign: %d" , wavH.blockAlign ); TRACE_3( FILEMANAGER , "bitsPerSample: %d" , wavH.bitsPerSample ); TRACE_3( FILEMANAGER , "Subchunk2ID: %s" , wavH.Subchunk2ID ); TRACE_3( FILEMANAGER , "Subchunk2Size: %d" , wavH.Subchunk2Size ); TRACE_3( FILEMANAGER , "######################################"); wavH.ChunkSize = 36 + wavH.Subchunk2Size; wavH.Subchunk1Size = 16; wavH.AudioFormat = 1; wavH.NumOfChan = 2; wavH.SamplesPerSec = 44100; wavH.bytesPerSec = wavH.SamplesPerSec * wavH.NumOfChan * 16 / 8; wavH.blockAlign = wavH.NumOfChan * 16 / 8; wavH.bitsPerSample = 16; memcpy( wavH.Subchunk2ID , "data" , 4 ); ret = fwrite( &wavH , sizeof( wavH ) , 1 , f ); if( ret != 1 ) { TRACE_ERROR( FILEMANAGER , "Fail to write all data."); status = PC_ERROR; } } fclose( f ); fclose( h ); } return status; }
/*! * \param *dc The current DecodingContext. * \param CurrMbAddr The address of the current macroblock. * \return The address of the next macroclock. * * Because this decoder do not support interlaced mode or slice partitioning or * flexible macroblock ordering (FMO) the NextMbAddress returned by this function * is always CurrMbAddr + 1. */ unsigned int NextMbAddress(DecodingContext_t *dc, const unsigned int CurrMbAddr) { TRACE_3(MB, "> " BLD_GREEN "NextMbAddress()" "= %i\n" CLR_RESET, CurrMbAddr + 1); return CurrMbAddr + 1; }
/* * wrapper for qi_putp entry in module ops vec. * implements asynchronous putnext(). * Note, that unlike putnext(), this routine is NOT optimized for the * fastpath. Calling this routine will grab whatever locks are necessary * to protect the stream head, q_next, and syncq's. * And since it is in the normal locks path, we do not use putlocks if * they exist (though this can be changed by swapping the value of * UseFastlocks). */ void put(queue_t *qp, mblk_t *mp) { queue_t *fqp = qp; /* For strft tracing */ syncq_t *sq; uint16_t flags; uint16_t drain_mask; struct qinit *qi; int (*putproc)(); int ix; boolean_t queued = B_FALSE; kmutex_t *sqciplock = NULL; ushort_t *sqcipcount = NULL; TRACE_2(TR_FAC_STREAMS_FR, TR_PUT_START, "put:(%X, %X)", qp, mp); ASSERT(mp->b_datap->db_ref != 0); ASSERT(mp->b_next == NULL && mp->b_prev == NULL); sq = qp->q_syncq; ASSERT(sq != NULL); qi = qp->q_qinfo; if (UseFastlocks && sq->sq_ciputctrl != NULL) { /* fastlock: */ ASSERT(sq->sq_flags & SQ_CIPUT); ix = CPU->cpu_seqid & sq->sq_nciputctrl; sqciplock = &sq->sq_ciputctrl[ix].ciputctrl_lock; sqcipcount = &sq->sq_ciputctrl[ix].ciputctrl_count; mutex_enter(sqciplock); if (!((*sqcipcount) & SQ_FASTPUT) || (sq->sq_flags & (SQ_STAYAWAY|SQ_EXCL|SQ_EVENTS))) { mutex_exit(sqciplock); sqciplock = NULL; goto slowlock; } (*sqcipcount)++; ASSERT(*sqcipcount != 0); queued = qp->q_sqflags & Q_SQQUEUED; mutex_exit(sqciplock); } else { slowlock: ASSERT(sqciplock == NULL); mutex_enter(SQLOCK(sq)); flags = sq->sq_flags; /* * We are going to drop SQLOCK, so make a claim to prevent syncq * from closing. */ sq->sq_count++; ASSERT(sq->sq_count != 0); /* Wraparound */ /* * If there are writers or exclusive waiters, there is not much * we can do. Place the message on the syncq and schedule a * background thread to drain it. * * Also if we are approaching end of stack, fill the syncq and * switch processing to a background thread - see comments on * top. */ if ((flags & (SQ_STAYAWAY|SQ_EXCL|SQ_EVENTS)) || (sq->sq_needexcl != 0) || PUT_STACK_NOTENOUGH()) { TRACE_3(TR_FAC_STREAMS_FR, TR_PUTNEXT_END, "putnext_end:(%p, %p, %p) SQ_EXCL fill", qp, mp, sq); /* * NOTE: qfill_syncq will need QLOCK. It is safe to drop * SQLOCK because positive sq_count keeps the syncq from * closing. */ mutex_exit(SQLOCK(sq)); qfill_syncq(sq, qp, mp); /* * NOTE: after the call to qfill_syncq() qp may be * closed, both qp and sq should not be referenced at * this point. * * This ASSERT is located here to prevent stack frame * consumption in the DEBUG code. */ ASSERT(sqciplock == NULL); return; } queued = qp->q_sqflags & Q_SQQUEUED; /* * If not a concurrent perimiter, we need to acquire * it exclusively. It could not have been previously * set since we held the SQLOCK before testing * SQ_GOAWAY above (which includes SQ_EXCL). * We do this here because we hold the SQLOCK, and need * to make this state change BEFORE dropping it. */ if (!(flags & SQ_CIPUT)) { ASSERT((sq->sq_flags & SQ_EXCL) == 0); ASSERT(!(sq->sq_type & SQ_CIPUT)); sq->sq_flags |= SQ_EXCL; } mutex_exit(SQLOCK(sq)); } ASSERT((sq->sq_flags & (SQ_EXCL|SQ_CIPUT))); ASSERT(MUTEX_NOT_HELD(SQLOCK(sq))); /* * We now have a claim on the syncq, we are either going to * put the message on the syncq and then drain it, or we are * going to call the putproc(). */ putproc = qi->qi_putp; if (!queued) { STR_FTEVENT_MSG(mp, fqp, FTEV_PUTNEXT, mp->b_rptr - mp->b_datap->db_base); (*putproc)(qp, mp); ASSERT(MUTEX_NOT_HELD(SQLOCK(sq))); ASSERT(MUTEX_NOT_HELD(QLOCK(qp))); } else { mutex_enter(QLOCK(qp)); /* * If there are no messages in front of us, just call putproc(), * otherwise enqueue the message and drain the queue. */ if (qp->q_syncqmsgs == 0) { mutex_exit(QLOCK(qp)); STR_FTEVENT_MSG(mp, fqp, FTEV_PUTNEXT, mp->b_rptr - mp->b_datap->db_base); (*putproc)(qp, mp); ASSERT(MUTEX_NOT_HELD(SQLOCK(sq))); } else { /* * We are doing a fill with the intent to * drain (meaning we are filling because * there are messages in front of us ane we * need to preserve message ordering) * Therefore, put the message on the queue * and call qdrain_syncq (must be done with * the QLOCK held). */ STR_FTEVENT_MSG(mp, fqp, FTEV_PUTNEXT, mp->b_rptr - mp->b_datap->db_base); #ifdef DEBUG /* * These two values were in the original code for * all syncq messages. This is unnecessary in * the current implementation, but was retained * in debug mode as it is usefull to know where * problems occur. */ mp->b_queue = qp; mp->b_prev = (mblk_t *)putproc; #endif SQPUT_MP(qp, mp); qdrain_syncq(sq, qp); ASSERT(MUTEX_NOT_HELD(QLOCK(qp))); } } /* * Before we release our claim, we need to see if any * events were posted. If the syncq is SQ_EXCL && SQ_QUEUED, * we were responsible for going exclusive and, therefore, * are resposible for draining. */ if (sq->sq_flags & (SQ_EXCL)) { drain_mask = 0; } else { drain_mask = SQ_QUEUED; } if (sqciplock != NULL) { mutex_enter(sqciplock); flags = sq->sq_flags; ASSERT(flags & SQ_CIPUT); /* SQ_EXCL could have been set by qwriter_inner */ if ((flags & (SQ_EXCL|SQ_TAIL)) || sq->sq_needexcl) { /* * we need SQLOCK to handle * wakeups/drains/flags change. sqciplock * is needed to decrement sqcipcount. * SQLOCK has to be grabbed before sqciplock * for lock ordering purposes. * after sqcipcount is decremented some lock * still needs to be held to make sure * syncq won't get freed on us. * * To prevent deadlocks we try to grab SQLOCK and if it * is held already we drop sqciplock, acquire SQLOCK and * reacqwire sqciplock again. */ if (mutex_tryenter(SQLOCK(sq)) == 0) { mutex_exit(sqciplock); mutex_enter(SQLOCK(sq)); mutex_enter(sqciplock); } flags = sq->sq_flags; ASSERT(*sqcipcount != 0); (*sqcipcount)--; mutex_exit(sqciplock); } else { ASSERT(*sqcipcount != 0); (*sqcipcount)--; mutex_exit(sqciplock); TRACE_3(TR_FAC_STREAMS_FR, TR_PUTNEXT_END, "putnext_end:(%p, %p, %p) done", qp, mp, sq); return; } } else { mutex_enter(SQLOCK(sq)); flags = sq->sq_flags; ASSERT(sq->sq_count != 0); sq->sq_count--; } if ((flags & (SQ_TAIL)) || sq->sq_needexcl) { putnext_tail(sq, qp, (flags & ~drain_mask)); /* * The only purpose of this ASSERT is to preserve calling stack * in DEBUG kernel. */ ASSERT(sq != NULL); return; } ASSERT((sq->sq_flags & (SQ_EXCL|SQ_CIPUT)) || queued); ASSERT((flags & (SQ_EXCL|SQ_CIPUT)) || queued); /* * Safe to always drop SQ_EXCL: * Not SQ_CIPUT means we set SQ_EXCL above * For SQ_CIPUT SQ_EXCL will only be set if the put * procedure did a qwriter(INNER) in which case * nobody else is in the inner perimeter and we * are exiting. * * I would like to make the following assertion: * * ASSERT((flags & (SQ_EXCL|SQ_CIPUT)) != (SQ_EXCL|SQ_CIPUT) || * sq->sq_count == 0); * * which indicates that if we are both putshared and exclusive, * we became exclusive while executing the putproc, and the only * claim on the syncq was the one we dropped a few lines above. * But other threads that enter putnext while the syncq is exclusive * need to make a claim as they may need to drop SQLOCK in the * has_writers case to avoid deadlocks. If these threads are * delayed or preempted, it is possible that the writer thread can * find out that there are other claims making the (sq_count == 0) * test invalid. */ sq->sq_flags = flags & ~SQ_EXCL; mutex_exit(SQLOCK(sq)); TRACE_3(TR_FAC_STREAMS_FR, TR_PUTNEXT_END, "putnext_end:(%p, %p, %p) done", qp, mp, sq); }
/*! * \param *dc The current DecodingContext. * \param mbAddr The current macroblock address. * \return 0 if macroblock decoding fail, 1 otherwise. * * This function extract one macroblock from the bitstream, handle intra/inter * prediction for its blocks. */ int macroblock_layer(DecodingContext_t *dc, const int mbAddr) { TRACE_INFO(MB, "<> " BLD_GREEN "macroblock_layer(" CLR_RESET "%i" BLD_GREEN ")\n" CLR_RESET, mbAddr); int retcode = FAILURE; // Macroblock allocation //////////////////////////////////////////////////////////////////////////// dc->mb_array[mbAddr] = (Macroblock_t*)calloc(1, sizeof(Macroblock_t)); if (dc->mb_array[mbAddr] == NULL) { TRACE_ERROR(MB, "Unable to alloc new macroblock!\n"); } else { // Set macroblock address dc->mb_array[mbAddr]->mbAddr = mbAddr; // Shortcuts pps_t *pps = dc->pps_array[dc->active_slice->pic_parameter_set_id]; sps_t *sps = dc->sps_array[pps->seq_parameter_set_id]; slice_t *slice = dc->active_slice; Macroblock_t *mb = dc->mb_array[mbAddr]; // Macroblock decoding //////////////////////////////////////////////////////////////////////// #if ENABLE_DEBUG mb->mbFileAddrStart = bitstream_get_absolute_bit_offset(dc->bitstr); #endif // ENABLE_DEBUG deriv_macroblockneighbours_availability(dc, mbAddr); MbPosition(mb, sps); if (pps->entropy_coding_mode_flag) mb->mb_type = read_ae(dc, SE_mb_type); else mb->mb_type = read_ue(dc->bitstr); mb->MbPartPredMode[0] = MbPartPredMode(mb, slice->slice_type, 0); mb->NumMbPart = NumMbPart(slice->slice_type, mb->mb_type); if (mb->mb_type == I_PCM) { #if ENABLE_IPCM TRACE_3(MB, "---- macroblock_layer - I PCM macroblock\n"); while (bitstream_check_alignment(dc->bitstr) == false) { if (read_bit(dc->bitstr) != 0) // pcm_alignment_zero_bit { TRACE_ERROR(MB, " Error while reading pcm_alignment_zero_bit: must be 0!\n"); return FAILURE; } } // CABAC initialization process //FIXME needed? See 'ITU-T H.264' recommendation 9.3.1.2 initCabacDecodingEngine(dc); int i = 0; for (i = 0; i < 256; i++) { mb->pcm_sample_luma[i] = (uint8_t)read_bits(dc->bitstr, sps->BitDepthY); } // CABAC initialization process //FIXME needed? See 'ITU-T H.264' recommendation 9.3.1.2 initCabacDecodingEngine(dc); for (i = 0; i < 2 * sps->MbWidthC * sps->MbHeightC; i++) { mb->pcm_sample_chroma[i] = (uint8_t)read_bits(dc->bitstr, sps->BitDepthC); } // CABAC initialization process //FIXME needed? See 'ITU-T H.264' recommendation 9.3.1.2 initCabacDecodingEngine(dc); #else // ENABLE_IPCM TRACE_ERROR(MB, "I_PCM decoding is currently disabled!\n"); return UNSUPPORTED; #endif // ENABLE_IPCM } else { #if ENABLE_INTER_PRED bool noSubMbPartSizeLessThan8x8Flag = true; if (mb->mb_type != I_NxN && mb->MbPartPredMode[0] != Intra_16x16 && mb->NumMbPart == 4) { TRACE_3(MB, "---- macroblock_layer - mb partition & related\n"); int mbPartIdx = 0; for (mbPartIdx = 0; mbPartIdx < 4; mbPartIdx++) { if (mb->sub_mb_type[mbPartIdx] != B_Direct_8x8) { if (NumSubMbPart(slice->slice_type, mb->sub_mb_type[mbPartIdx]) > 1) { noSubMbPartSizeLessThan8x8Flag = false; } } else if (sps->direct_8x8_inference_flag == false) { noSubMbPartSizeLessThan8x8Flag = false; } } // Read sub macroblock prediction mode sub_mb_pred(dc, mb->mb_type, mb->sub_mb_type); } else #endif // ENABLE_INTER_PRED { TRACE_3(MB, "---- macroblock_layer - transform_size_8x8_flag & prediction modes\n"); if (pps->transform_8x8_mode_flag == true && mb->mb_type == I_NxN) { if (pps->entropy_coding_mode_flag) mb->transform_size_8x8_flag = read_ae(dc, SE_transform_size_8x8_flag); else mb->transform_size_8x8_flag = read_bit(dc->bitstr); // Need to update MbPartPredMode in order to detect I_8x8 prediction mode mb->MbPartPredMode[0] = MbPartPredMode(mb, slice->slice_type, 0); } // Read macroblock prediction mode mb_pred(dc, mb); } if (mb->MbPartPredMode[0] != Intra_16x16) { TRACE_3(MB, "---- macroblock_layer - coded block pattern & transform_size_8x8_flag\n"); if (pps->entropy_coding_mode_flag) mb->coded_block_pattern = read_ae(dc, SE_coded_block_pattern); else mb->coded_block_pattern = read_me(dc->bitstr, sps->ChromaArrayType, dc->IdrPicFlag); mb->CodedBlockPatternLuma = mb->coded_block_pattern % 16; mb->CodedBlockPatternChroma = mb->coded_block_pattern / 16; #if ENABLE_INTER_PRED if (mb->CodedBlockPatternLuma > 0 && pps->transform_8x8_mode_flag == true && mb->mb_type != I_NxN && noSubMbPartSizeLessThan8x8Flag == true && (mb->mb_type != B_Direct_16x16 || sps->direct_8x8_inference_flag == true)) { if (pps->entropy_coding_mode_flag) mb->transform_size_8x8_flag = read_ae(dc, SE_transform_size_8x8_flag); else mb->transform_size_8x8_flag = read_bit(dc->bitstr); // Need to update MbPartPredMode in order to account for I_8x8 prediction mode if (transform_size_8x8_flag) mb->MbPartPredMode[0] = MbPartPredMode(mb, slice->slice_type, 0); } #endif // ENABLE_INTER_PRED } if (mb->CodedBlockPatternLuma > 0 || mb->CodedBlockPatternChroma > 0 || mb->MbPartPredMode[0] == Intra_16x16) { TRACE_3(MB, "---- macroblock_layer - quantization parameter & residual datas\n"); // Read QP delta if (pps->entropy_coding_mode_flag) mb->mb_qp_delta = read_ae(dc, SE_mb_qp_delta); else mb->mb_qp_delta = read_se(dc->bitstr); // Parse the residual coefficients //////////////////////////////////////////////////////////////// // Luma levels residual_luma(dc, 0, 15); // Chroma levels residual_chroma(dc, 0, 15); } else { TRACE_3(MB, "---- macroblock_layer - No residual datas to decode in this macroblock\n"); } // Compute luma Quantization Parameters if (mb->mb_qp_delta) mb->QPY = ((slice->QPYprev + mb->mb_qp_delta + 52 + sps->QpBdOffsetY*2) % (52 + sps->QpBdOffsetY)) - sps->QpBdOffsetY; else mb->QPY = slice->QPYprev; mb->QPprimeY = mb->QPY + sps->QpBdOffsetY; slice->QPYprev = mb->QPY; // Set Transform Bypass Mode if (sps->qpprime_y_zero_transform_bypass_flag == true && mb->QPprimeY == 0) mb->TransformBypassModeFlag = true; // Prediction process (include quantization and transformation stages) //////////////////////////////////////////////////////////////// if (dc->IdrPicFlag) { retcode = intra_prediction_process(dc, mb); } else { retcode = inter_prediction_process(dc, mb); } // Print macroblock(s) header and block data ? //////////////////////////////////////////////////////////////// #if ENABLE_DEBUG mb->mbFileAddrStop = bitstream_get_absolute_bit_offset(dc->bitstr) - 1; int frame_debug_range[2] = {-1, -1}; // Range of (idr) frame(s) to debug/analyse int mb_debug_range[2] = {-1, -1}; // Range of macroblock(s) to debug/analyse if (dc->idrCounter >= frame_debug_range[0] && dc->idrCounter <= frame_debug_range[1]) { if (mb->mbAddr >= mb_debug_range[0] && mb->mbAddr <= mb_debug_range[1]) { print_macroblock_layer(dc, mb); print_macroblock_pixel_residual(mb); print_macroblock_pixel_predicted(mb); print_macroblock_pixel_final(mb); } } #endif // ENABLE_DEBUG } TRACE_3(MB, "---- macroblock_layer - the end\n\n"); } return retcode; }
/** * Return number of log files in a dir and the name of the oldest file. * @param indata, see gnolfh_in_t * @param outdata, char *oldest_file * @param max_outsize, Max size for oldest_file string * * @return int, number of logfiles or -1 if error */ int get_number_of_log_files_hdl(void *indata, void *outdata, size_t max_outsize) { struct dirent **namelist; int n, old_date = -1, old_time = -1, old_ind = -1, files, i, failed = 0; char path[PATH_MAX]; gnolfh_in_t *params_in; char *oldest_file; int rc = 0; TRACE_ENTER(); params_in = (gnolfh_in_t *) indata; oldest_file = (char *) outdata; /* Initialize the filter */ n = snprintf(file_prefix, SA_MAX_NAME_LENGTH, "%s", params_in->file_name); if (n >= SA_MAX_NAME_LENGTH) { rc = -1; LOG_WA("file_prefix > SA_MAX_NAME_LENGTH"); goto done_exit; } n = snprintf(path, PATH_MAX, "%s/%s", params_in->logsv_root_dir, params_in->pathName); if (n >= PATH_MAX) { LOG_WA("path > PATH_MAX"); rc = -1; goto done_exit; } files = n = scandir(path, &namelist, filter_func, alphasort); if (n == -1 && errno == ENOENT) { rc = 0; goto done_exit; } if (n < 0) { LOG_WA("scandir:%s - %s", strerror(errno), path); rc = -1; goto done_exit; } if (n == 0) { rc = files; goto done_exit; } while (n--) { TRACE_3("%s", namelist[n]->d_name); if (check_oldest(namelist[n]->d_name, params_in->file_name, strlen(params_in->file_name), &old_date, &old_time)) { old_ind = n; } else { failed++; /* wrong format */ } } if (old_ind != -1) { TRACE_1("oldest: %s", namelist[old_ind]->d_name); n = snprintf(oldest_file, max_outsize, "%s/%s", path, namelist[old_ind]->d_name); if (n >= max_outsize) { LOG_WA("oldest_file > max_outsize"); rc = -1; goto done_free; } else { rc = (files - failed); } } else { TRACE("Only file/files with wrong format found"); } done_free: /* Free scandir allocated memory */ for (i = 0; i < files; i++) free(namelist[i]); free(namelist); done_exit: TRACE_LEAVE(); return rc; }
/* void *arg is a argumentReceivingThread_t type */ void receivingThread( void *arg ) { TRACE_2( SERVERMANAGER , "receivingThread()"); char buff[BUFF_SIZE]; char input[] = "wMusic~>"; int ret; int info; void *cliRet; argumentReceivingThread_t *arguments = ( argumentReceivingThread_t * )arg; TRACE_3( SERVERMANAGER , "Thread argument: socket: %d , port: %d" , arguments->socket , arguments->port ); TRACE_1( SERVERMANAGER , "[!]Receiving thread create !"); if( arguments->port == PORT_CLI ) sendVoidSocket( arguments->socket , input , sizeof( input ) ); else //usleep( 2000 ) for WAN connection, usleep( 300 ) for LAN connection. usleep( 2000 ); info = IAMBRIDGE; sendVoidSocket( arguments->socket , ( void *)&info , sizeof( int ) ); //Sending info that the remote is connected to a bridge. while( 1 ) { memset( buff , 0 , BUFF_SIZE ); ret = recv( arguments->socket , buff , BUFF_SIZE , 0 ); if( ret > 0 ) { if( arguments->port == PORT_COMMANDER ) { TRACE_3( SERVERMANAGER , "[+]Data: %s" , buff ); if( strstr( buff , "DISC") != NULL ) { disconnectClient( &arguments->socket ); break; } lastRequester = arguments->socket; doAction( buff ); } else if( arguments->port == PORT_CLI ) { TRACE_3( SERVERMANAGER , "[+]Data: %s" , buff ); cliRet = doCommand( buff ); if( cliRet != NULL ) { sendVoidSocket( arguments->socket , cliRet , strlen( ( const char * )cliRet ) ); zfree( cliRet ); sendVoidSocket( arguments->socket , input , sizeof( input ) ); } } } } TRACE_3( SERVERMANAGER , "[!]Quitting receiving thread !"); releaseThread(); pthread_exit( NULL ); }
/* * Find the largest contiguous block which contains `addr' for file offset * `offset' in it while living within the file system block sizes (`vp_off' * and `vp_len') and the address space limits for which no pages currently * exist and which map to consecutive file offsets. */ page_t * pvn_read_kluster( struct vnode *vp, u_offset_t off, struct seg *seg, caddr_t addr, u_offset_t *offp, /* return values */ size_t *lenp, /* return values */ u_offset_t vp_off, size_t vp_len, int isra) { ssize_t deltaf, deltab; page_t *pp; page_t *plist = NULL; spgcnt_t pagesavail; u_offset_t vp_end; ASSERT(off >= vp_off && off < vp_off + vp_len); /* * We only want to do klustering/read ahead if there * is more than minfree pages currently available. */ pagesavail = freemem - minfree; if (pagesavail <= 0) if (isra) return ((page_t *)NULL); /* ra case - give up */ else pagesavail = 1; /* must return a page */ /* We calculate in pages instead of bytes due to 32-bit overflows */ if (pagesavail < (spgcnt_t)btopr(vp_len)) { /* * Don't have enough free memory for the * max request, try sizing down vp request. */ deltab = (ssize_t)(off - vp_off); vp_len -= deltab; vp_off += deltab; if (pagesavail < btopr(vp_len)) { /* * Still not enough memory, just settle for * pagesavail which is at least 1. */ vp_len = ptob(pagesavail); } } vp_end = vp_off + vp_len; ASSERT(off >= vp_off && off < vp_end); if (isra && SEGOP_KLUSTER(seg, addr, 0)) return ((page_t *)NULL); /* segment driver says no */ if ((plist = page_create_va(vp, off, PAGESIZE, PG_EXCL | PG_WAIT, seg, addr)) == NULL) return ((page_t *)NULL); if (vp_len <= PAGESIZE || pvn_nofodklust) { *offp = off; *lenp = MIN(vp_len, PAGESIZE); } else { /* * Scan back from front by incrementing "deltab" and * comparing "off" with "vp_off + deltab" to avoid * "signed" versus "unsigned" conversion problems. */ for (deltab = PAGESIZE; off >= vp_off + deltab; deltab += PAGESIZE) { /* * Call back to the segment driver to verify that * the klustering/read ahead operation makes sense. */ if (SEGOP_KLUSTER(seg, addr, -deltab)) break; /* page not eligible */ if ((pp = page_create_va(vp, off - deltab, PAGESIZE, PG_EXCL, seg, addr - deltab)) == NULL) break; /* already have the page */ /* * Add page to front of page list. */ page_add(&plist, pp); } deltab -= PAGESIZE; /* scan forward from front */ for (deltaf = PAGESIZE; off + deltaf < vp_end; deltaf += PAGESIZE) { /* * Call back to the segment driver to verify that * the klustering/read ahead operation makes sense. */ if (SEGOP_KLUSTER(seg, addr, deltaf)) break; /* page not file extension */ if ((pp = page_create_va(vp, off + deltaf, PAGESIZE, PG_EXCL, seg, addr + deltaf)) == NULL) break; /* already have page */ /* * Add page to end of page list. */ page_add(&plist, pp); plist = plist->p_next; } *offp = off = off - deltab; *lenp = deltab + deltaf; ASSERT(off >= vp_off); /* * If we ended up getting more than was actually * requested, retract the returned length to only * reflect what was requested. This might happen * if we were allowed to kluster pages across a * span of (say) 5 frags, and frag size is less * than PAGESIZE. We need a whole number of * pages to contain those frags, but the returned * size should only allow the returned range to * extend as far as the end of the frags. */ if ((vp_off + vp_len) < (off + *lenp)) { ASSERT(vp_end > off); *lenp = vp_end - off; } } TRACE_3(TR_FAC_VM, TR_PVN_READ_KLUSTER, "pvn_read_kluster:seg %p addr %x isra %x", seg, addr, isra); return (plist); }