Problem B. Problem Select (atoi()函数)

本文介绍了一个在线判题系统(HOJ)中选取问题的算法实现。该算法接收一系列URL作为输入,从中提取问题ID,并输出按升序排列的最小k个问题ID。适用于竞赛组织者快速筛选并设置比赛题目。

Problem B. Problem Select
Input file: standard input
Output file: standard output
Time limit: 1 second
Memory limit: 256 megabytes
HOJ is an online judge system for students in HIT to practice. As the administrator, you would always
setup contests by selecting problems from the problem set. Problem IDs are integers that can be phased
by url. For example, the corresponding problem ID of url http://acm.hit.edu.cn/problemset/1001
is 1001.
Now the task is, given n urls, print the smallest k problem IDs in increasing order.
Input
The first line of the input contains one integer T (1 ≤ T ≤ 10), indicating the number of test cases.
For each test case, the first line contains two integers, n (1 ≤ n ≤ 1000) and k (1 ≤ k ≤ n).
For the next n lines, each line contains a string indicating the problem’s url. The problem ID is guaranteed
to be in range [1, 10000] and unique in each case.
Output
Output T lines.
For each test case, you should output k numbers in a line, and there shouldn’t be any spaces at the end
of the line.
Example
standard input
2
3 2
http://acm.hit.edu.cn/problemset/1003
http://acm.hit.edu.cn/problemset/1002
http://acm.hit.edu.cn/problemset/1001
4 1
http://acm.hit.edu.cn/problemset/1001
http://acm.hit.edu.cn/problemset/2001
http://acm.hit.edu.cn/problemset/3001
http://acm.hit.edu.cn/problemset/501
standard output
1001 1002
501

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int a[10010];
    char s[110];
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,m;
        scanf("%d %d",&n,&m);
        getchar();
        for(int i=1;i<=n;i++)
        {
            scanf("%s",s);
            int x=atoi(s+33);
            a[i]=x;
        }
        sort(a+1,a+n+1);
        for(int i=1;i<m;i++)
         printf("%d ",a[i]);
         printf("%d\n",a[m]);;

    }
    return 0;
}

基于上面代码修改下面的代码来实现以IO多路复用方式实现web server功能,尽可能小幅度修改下面的代码, /*! * ************************************************************************************************* * @copyright(c) 2008-2025 Shenzhen TP-LINK Technologies Co.Ltd. * * @file http.c * @brief * * @author huyushuai * @version 1.0.0 * @date 2025-08-08 * ************************************************************************************************* */ /**************************************************************************************************/ /* INCLUDE_FILES */ /**************************************************************************************************/ #include <stdio.h> #include <stdbool.h> #include <sys/socket.h> #include <sys/types.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #include <ctype.h> #include <strings.h> #include <string.h> #include <sys/stat.h> #include <pthread.h> #include <sys/wait.h> #include <stdlib.h> #include <errno.h> #include <signal.h> #include <stdatomic.h> #include <sys/wait.h> /**************************************************************************************************/ /* DEFINES */ /**************************************************************************************************/ #define ISspace(x) isspace((int)(x)) #define SERVER_STRING "Server: jdbhttpd/0.1.0\r\n" #define MAX_PROCESSES 100 // 最大子进程数量限制 #define DOCUMENT_ROOT "htdocs" /**************************************************************************************************/ /* LOCAL_PROTOTYPES */ /**************************************************************************************************/ void accept_request(int client_sock); void bad_request(int client); void cat(int, FILE *); void cannot_execute(int); void error_die(const char *); void execute_cgi(int, const char *, const char *, const char *); int get_line(int, char *, int); void headers(int, const char *); void not_found(int); void serve_file(int, const char *); int startup(u_short *); void unimplemented(int); void normalize_path(char *path); const char *get_content_type(const char *path); void handle_sigpipe(int sig); /**************************************************************************************************/ /* LOCAL_FUNCTIONS */ /**************************************************************************************************/ /*! * @brief 路径规范函数 * * @param[in] path 文件路径 */ void normalize_path(char *path) { char *p = path; char *q = path; while (*p) { if (strncmp(p, "/../", 4) == 0) { p += 3; while (q > path && *--q != '/') { ; } } else if (strncmp(p, "/./", 3) == 0) { p += 2; } else if (strncmp(p, "//", 2) == 0) { p += 1; } else { *q++ = *p++; } } *q = '\0'; } /*! * @brief 忽略SIGPIPE信号处理 * * @param[in] sig SIGPIPE信号 */ void handle_sigpipe(int sig) { } /*! * @brief * * @param[in] ctx Comment */ void accept_request(int client_sock) { int client = client_sock; char buf[1024]; char method[255]; char url[255]; char path[512]; struct stat st; int cgi = 0; char *query_string = NULL; int numchars = get_line(client, buf, sizeof(buf)); size_t i = 0; size_t j = 0; while (!ISspace(buf[j]) && (i < sizeof(method) - 1)) { method[i] = buf[j]; i++; j++; } method[i] = '\0'; // 只支持GET和POST方法 if (strcasecmp(method, "GET") && strcasecmp(method, "POST")) { unimplemented(client); close(client); return; } // POST请求启用CGI if (strcasecmp(method, "POST") == 0) { cgi = 1; } i = 0; while (ISspace(buf[j]) && (j < sizeof(buf))) { j++; } while (!ISspace(buf[j]) && (i < sizeof(url) - 1) && (j < sizeof(buf))) { url[i] = buf[j]; i++; j++; } url[i] = '\0'; // 处理GET查询参数 if (strcasecmp(method, "GET") == 0) { query_string = url; while ((*query_string != '?') && (*query_string != '\0')) query_string++; if (*query_string == '?') { cgi = 1; *query_string = '\0'; query_string++; } } // 构建安全路径 if (strlen(url) == 0 || strstr(url, "..") != NULL) { bad_request(client); close(client); return; } snprintf(path, sizeof(path), "%s%s", DOCUMENT_ROOT, url); normalize_path(path); // 确保路径在文档根目录内 if (strncmp(path, DOCUMENT_ROOT, strlen(DOCUMENT_ROOT)) != 0) { not_found(client); close(client); return; } if (path[strlen(path) - 1] == '/') { strncat(path, "index.html", sizeof(path) - strlen(path) - 1); } if (stat(path, &st) == -1) { while ((numchars > 0) && strcmp("\n", buf) != 0) { numchars = get_line(client, buf, sizeof(buf)); } not_found(client); } else { if (S_ISDIR(st.st_mode)) { strncat(path, "/index.html", sizeof(path) - strlen(path) - 1); stat(path, &st); } if ((st.st_mode & S_IXUSR) || (st.st_mode & S_IXGRP) || (st.st_mode & S_IXOTH)) { cgi = 1; } if (!cgi) { serve_file(client, path); } else { execute_cgi(client, path, method, query_string); } } /* 清理资源 */ close(client); } /**********************************************************************/ /* Inform the client that a request it has made has a problem. * Parameters: client socket */ /**********************************************************************/ void bad_request(int client) { char buf[1024]; sprintf(buf, "HTTP/1.0 400 BAD REQUEST\r\n"); send(client, buf, sizeof(buf), 0); sprintf(buf, "Content-type: text/html\r\n"); send(client, buf, sizeof(buf), 0); sprintf(buf, "\r\n"); send(client, buf, sizeof(buf), 0); sprintf(buf, "<P>Your browser sent a bad request, "); send(client, buf, sizeof(buf), 0); sprintf(buf, "such as a POST without a Content-Length.\r\n"); send(client, buf, sizeof(buf), 0); } /*! * @brief 将文件内容发送到网络客户端 * * @param[in] client 客户端套接字描述符 * @param[in] resource 文件指针(指向要发送的文件) */ void cat(int client, FILE *resource) { char buf[1024]; size_t bytes_read; while ((bytes_read = fread(buf, 1, sizeof(buf), resource)) > 0) { if (send(client, buf, bytes_read, 0) < bytes_read) { perror("send"); break; } } } /**********************************************************************/ /* Inform the client that a CGI script could not be executed. * Parameter: the client socket descriptor. */ /**********************************************************************/ void cannot_execute(int client) { char buf[1024]; sprintf(buf, "HTTP/1.0 500 Internal Server Error\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "Content-type: text/html\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "<P>Error prohibited CGI execution.\r\n"); send(client, buf, strlen(buf), 0); } /**********************************************************************/ /* Print out an error message with perror() (for system errors; based * on value of errno, which indicates system call errors) and exit the * program indicating an error. */ /**********************************************************************/ void error_die(const char *sc) { perror(sc); exit(1); } /**********************************************************************/ /* Execute a CGI script. Will need to set environment variables as * appropriate. * Parameters: client socket descriptor * path to the CGI script */ /**********************************************************************/ void execute_cgi(int client, const char *path, const char *method, const char *query_string) { // 缓冲区 char buf[1024]; int cgi_output[2]; int cgi_input[2]; pid_t pid; int status; int i = 0; char c; int numchars = 1; int content_length = -1; // 默认字符 buf[0] = 'A'; buf[1] = '\0'; // 忽略大小写比较字符串 if (strcasecmp(method, "GET") == 0) { while ((numchars > 0) && strcmp("\n", buf)) /* read & discard headers */ { numchars = get_line(client, buf, sizeof(buf)); } } else /* POST */ { numchars = get_line(client, buf, sizeof(buf)); while ((numchars > 0) && strcmp("\n", buf)) { buf[15] = '\0'; if (strcasecmp(buf, "Content-Length:") == 0) { content_length = atoi(&(buf[16])); } numchars = get_line(client, buf, sizeof(buf)); } if (content_length == -1) { bad_request(client); return; } } sprintf(buf, "HTTP/1.0 200 OK\r\n"); send(client, buf, strlen(buf), 0); /* 建立output管道 */ if (pipe(cgi_output) < 0) { cannot_execute(client); return; } /* 建立input管道 */ if (pipe(cgi_input) < 0) { cannot_execute(client); return; } if ((pid = fork()) < 0) { cannot_execute(client); return; } if (pid == 0) /* child: CGI script */ { char meth_env[255]; char query_env[255]; char length_env[255]; // 子进程输出重定向到output管道的1端 dup2(cgi_output[1], 1); // 子进程输入重定向到input管道的0端 dup2(cgi_input[0], 0); // 关闭无用管道口 close(cgi_output[0]); close(cgi_input[1]); // CGI环境变量 sprintf(meth_env, "REQUEST_METHOD=%s", method); putenv(meth_env); if (strcasecmp(method, "GET") == 0) { sprintf(query_env, "QUERY_STRING=%s", query_string); putenv(query_env); } else { /* POST */ sprintf(length_env, "CONTENT_LENGTH=%d", content_length); putenv(length_env); } // 替换执行path execl(path, path, NULL); // int m = execl(path, path, NULL); // 如果path有问题,例如将html网页改成可执行的,但是执行后m为-1 // 退出子进程,管道被破坏,但是父进程还在往里面写东西,触发Program received signal SIGPIPE, Broken pipe. exit(0); } else { /* parent */ close(cgi_output[1]); close(cgi_input[0]); if (strcasecmp(method, "POST") == 0) { for (i = 0; i < content_length; i++) { recv(client, &c, 1, 0); ssize_t bytes_written = write(cgi_input[1], &c, 1); if (bytes_written <= 0) { perror("Failed to write to CGI"); close(cgi_input[1]); close(cgi_input[0]); break; } } } while (read(cgi_output[0], &c, 1) > 0) { send(client, &c, 1, 0); } close(cgi_output[0]); close(cgi_input[1]); waitpid(pid, &status, 0); } } /**********************************************************************/ /* Get a line from a socket, whether the line ends in a newline, * carriage return, or a CRLF combination. Terminates the string read * with a null character. If no newline indicator is found before the * end of the buffer, the string is terminated with a null. If any of * the above three line terminators is read, the last character of the * string will be a linefeed and the string will be terminated with a * null character. * Parameters: the socket descriptor * the buffer to save the data in * the size of the buffer * Returns: the number of bytes stored (excluding null) */ /**********************************************************************/ // 得到一行数据,只要发现c为\n,就认为是一行结束,如果读到\r,再用MSG_PEEK的方式读入一个字符,如果是\n,从socket用读出 // 如果是下个字符则不处理,将c置为\n,结束。如果读到的数据为0中断,或者小于0,也视为结束,c置为\n /*! * @brief 从socket中获取一行数据 * * @param[in] sock socket * @param[in] buf 用于保存数据的缓冲区 * @param[in] size 缓冲区的大小 * @return int 存储的字节数 */ int get_line(int sock, char *buf, int size) { int i = 0; char c = '\0'; int n; while ((i < size - 1) && (c != '\n')) { n = recv(sock, &c, 1, 0); if (n > 0) { if (c == '\r') { n = recv(sock, &c, 1, MSG_PEEK); if ((n > 0) && (c == '\n')) { recv(sock, &c, 1, 0); } else { c = '\n'; } } buf[i] = c; i++; } else c = '\n'; } buf[i] = '\0'; return (i); } /*! * @brief 根据文件路径的扩展名返回对应的 MIME 类型 * * @param[in] path 路径字符串 * @return const char* */ const char *get_content_type(const char *path) { const char *ext = strrchr(path, '.'); if (ext) { if (strcasecmp(ext, ".css") == 0) { return "text/css"; } if (strcasecmp(ext, ".js") == 0) { return "application/javascript"; } if (strcasecmp(ext, ".png") == 0) { return "image/png"; } if (strcasecmp(ext, ".jpg") == 0 || strcasecmp(ext, ".jpeg") == 0) { return "image/jpeg"; } if (strcasecmp(ext, ".gif") == 0) { return "image/gif"; } if (strcasecmp(ext, ".ico") == 0) { return "image/x-icon"; } if (strcasecmp(ext, ".svg") == 0) { return "image/svg+xml"; } if (strcasecmp(ext, ".woff") == 0) { return "font/woff"; } if (strcasecmp(ext, ".woff2") == 0) { return "font/woff2"; } } return "text/html"; } /*! * @brief 发送HTTP响应头 * * @param[in] client 客户端 * @param[in] filename 文件名 */ void headers(int client, const char *filename) { char buf[1024]; const char *content_type = get_content_type(filename); sprintf(buf, "HTTP/1.0 200 OK\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, SERVER_STRING); send(client, buf, strlen(buf), 0); sprintf(buf, "Content-Type: %s\r\n", content_type); send(client, buf, strlen(buf), 0); sprintf(buf, "\r\n"); send(client, buf, strlen(buf), 0); } /*! * @brief 404 * * @param[in] client 客户端 */ void not_found(int client) { char buf[1024]; sprintf(buf, "HTTP/1.0 404 NOT FOUND\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, SERVER_STRING); send(client, buf, strlen(buf), 0); sprintf(buf, "Content-Type: text/html\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "<HTML><TITLE>Not Found</TITLE>\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "<BODY><P>The server could not fulfill\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "your request because the resource specified\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "is unavailable or nonexistent.\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "</BODY></HTML>\r\n"); send(client, buf, strlen(buf), 0); } /*! * @brief 如果不是CGI文件,直接读取文件返回给请求的http客户端 * * @param[in] client 客户端 * @param[in] filename 文件名 */ void serve_file(int client, const char *filename) { FILE *resource = NULL; int numchars = 1; char buf[1024]; buf[0] = 'A'; buf[1] = '\0'; while ((numchars > 0) && strcmp("\n", buf)) { numchars = get_line(client, buf, sizeof(buf)); } resource = fopen(filename, "rb"); if (resource == NULL) { not_found(client); } else { headers(client, filename); cat(client, resource); } fclose(resource); } /**********************************************************************/ /* This function starts the process of listening for web connections * on a specified port. If the port is 0, then dynamically allocate a * port and modify the original port variable to reflect the actual * port. * Parameters: pointer to variable containing the port to connect on * Returns: the socket */ /**********************************************************************/ int startup(u_short *port) { int httpd = 0; struct sockaddr_in name; httpd = socket(PF_INET, SOCK_STREAM, 0); if (httpd == -1) { error_die("socket"); } memset(&name, 0, sizeof(name)); name.sin_family = AF_INET; name.sin_port = htons(*port); name.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(httpd, (struct sockaddr *)&name, sizeof(name)) < 0) { error_die("bind"); } if (*port == 0) { socklen_t namelen = sizeof(name); if (getsockname(httpd, (struct sockaddr *)&name, &namelen) == -1) { error_die("getsockname"); } *port = ntohs(name.sin_port); } if (listen(httpd, 5) < 0) { error_die("listen"); } return (httpd); } /*! * @brief 没有实现请求 * * @param[in] client 客户端 */ void unimplemented(int client) { char buf[1024]; sprintf(buf, "HTTP/1.0 501 Method Not Implemented\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, SERVER_STRING); send(client, buf, strlen(buf), 0); sprintf(buf, "Content-Type: text/html\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "<HTML><HEAD><TITLE>Method Not Implemented\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "</TITLE></HEAD>\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "<BODY><P>HTTP request method not supported.\r\n"); send(client, buf, strlen(buf), 0); sprintf(buf, "</BODY></HTML>\r\n"); send(client, buf, strlen(buf), 0); } int main(void) { int server_sock = -1; u_short port = 80; // 使用8080端口避免权限问题 struct sockaddr_in client_name; socklen_t client_name_len = sizeof(client_name); // 设置信号处理 signal(SIGPIPE, handle_sigpipe); server_sock = startup(&port); printf("HTTP server running on port %d\n", port); while (1) { int client_sock = accept(server_sock, (struct sockaddr *)&client_name, &client_name_len); if (client_sock == -1) { perror("accept failed"); continue; } pid_t pid = fork(); if (pid < 0) { perror("fork failed"); close(client_sock); } else if (0 == pid) { close(server_sock); accept_request(client_sock); exit(EXIT_SUCCESS); } else { close(client_sock); } } close(server_sock); return 0; }
08-09
/ prepareTracks_l() must be called with ThreadBase::mLock held AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l( Vector< sp<Track> > *tracksToRemove) { mixer_state mixerStatus = MIXER_IDLE; // find out which tracks need to be processed size_t count = mActiveTracks.size(); size_t mixedTracks = 0; size_t tracksWithEffect = 0; // counts only _active_ fast tracks size_t fastTracks = 0; uint32_t resetMask = 0; // bit mask of fast tracks that need to be reset float masterVolume = mMasterVolume; bool masterMute = mMasterMute; if (masterMute) { masterVolume = 0; } // Delegate master volume control to effect in output mix effect chain if needed sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX); if (chain != 0) { uint32_t v = (uint32_t)(masterVolume * (1 << 24)); chain->setVolume_l(&v, &v); masterVolume = (float)((v + (1 << 23)) >> 24); chain.clear(); } // prepare a new state to push FastMixerStateQueue *sq = NULL; FastMixerState *state = NULL; bool didModify = false; FastMixerStateQueue::block_t block = FastMixerStateQueue::BLOCK_UNTIL_PUSHED; if (mFastMixer != 0) { sq = mFastMixer->sq(); state = sq->begin(); } mMixerBufferValid = false; // mMixerBuffer has no valid data until appropriate tracks found. mEffectBufferValid = false; // mEffectBuffer has no valid data until tracks found. for (size_t i=0 ; i<count ; i++) { const sp<Track> t = mActiveTracks[i].promote(); if (t == 0) { continue; } // this const just means the local variable doesn't change Track* const track = t.get(); // process fast tracks if (track->isFastTrack()) { // It's theoretically possible (though unlikely) for a fast track to be created // and then removed within the same normal mix cycle. This is not a problem, as // the track never becomes active so it's fast mixer slot is never touched. // The converse, of removing an (active) track and then creating a new track // at the identical fast mixer slot within the same normal mix cycle, // is impossible because the slot isn't marked available until the end of each cycle. int j = track->mFastIndex; ALOG_ASSERT(0 < j && j < (int)FastMixerState::sMaxFastTracks); ALOG_ASSERT(!(mFastTrackAvailMask & (1 << j))); FastTrack *fastTrack = &state->mFastTracks[j]; // Determine whether the track is currently in underrun condition, // and whether it had a recent underrun. FastTrackDump *ftDump = &mFastMixerDumpState.mTracks[j]; FastTrackUnderruns underruns = ftDump->mUnderruns; uint32_t recentFull = (underruns.mBitFields.mFull - track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK; uint32_t recentPartial = (underruns.mBitFields.mPartial - track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK; uint32_t recentEmpty = (underruns.mBitFields.mEmpty - track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK; uint32_t recentUnderruns = recentPartial + recentEmpty; track->mObservedUnderruns = underruns; // don't count underruns that occur while stopping or pausing // or stopped which can occur when flush() is called while active if (!(track->isStopping() || track->isPausing() || track->isStopped()) && recentUnderruns > 0) { // FIXME fast mixer will pull & mix partial buffers, but we count as a full underrun track->mAudioTrackServerProxy->tallyUnderrunFrames(recentUnderruns * mFrameCount); } else { track->mAudioTrackServerProxy->tallyUnderrunFrames(0); } // This is similar to the state machine for normal tracks, // with a few modifications for fast tracks. bool isActive = true; switch (track->mState) { case TrackBase::STOPPING_1: // track stays active in STOPPING_1 state until first underrun if (recentUnderruns > 0 || track->isTerminated()) { track->mState = TrackBase::STOPPING_2; } break; case TrackBase::PAUSING: // ramp down is not yet implemented track->setPaused(); break; case TrackBase::RESUMING: // ramp up is not yet implemented track->mState = TrackBase::ACTIVE; break; case TrackBase::ACTIVE: if (recentFull > 0 || recentPartial > 0) { // track has provided at least some frames recently: reset retry count track->mRetryCount = kMaxTrackRetries; } if (recentUnderruns == 0) { // no recent underruns: stay active break; } // there has recently been an underrun of some kind if (track->sharedBuffer() == 0) { // were any of the recent underruns "empty" (no frames available)? if (recentEmpty == 0) { // no, then ignore the partial underruns as they are allowed indefinitely break; } // there has recently been an "empty" underrun: decrement the retry counter if (--(track->mRetryCount) > 0) { break; } // indicate to client process that the track was disabled because of underrun; // it will then automatically call start() when data is available track->disable(); // remove from active list, but state remains ACTIVE [confusing but true] isActive = false; break; } // fall through case TrackBase::STOPPING_2: case TrackBase::PAUSED: case TrackBase::STOPPED: case TrackBase::FLUSHED: // flush() while active // Check for presentation complete if track is inactive // We have consumed all the buffers of this track. // This would be incomplete if we auto-paused on underrun { size_t audioHALFrames = (mOutput->stream->get_latency(mOutput->stream)*mSampleRate) / 1000; int64_t framesWritten = mBytesWritten / mFrameSize; if (!(mStandby || track->presentationComplete(framesWritten, audioHALFrames))) { // track stays in active list until presentation is complete break; } } if (track->isStopping_2()) { track->mState = TrackBase::STOPPED; } if (track->isStopped()) { // Can't reset directly, as fast mixer is still polling this track // track->reset(); // So instead mark this track as needing to be reset after push with ack resetMask |= 1 << i; } isActive = false; break; case TrackBase::IDLE: default: LOG_ALWAYS_FATAL("unexpected track state %d", track->mState); } if (isActive) { // was it previously inactive? if (!(state->mTrackMask & (1 << j))) { ExtendedAudioBufferProvider *eabp = track; VolumeProvider *vp = track; fastTrack->mBufferProvider = eabp; fastTrack->mVolumeProvider = vp; fastTrack->mChannelMask = track->mChannelMask; fastTrack->mFormat = track->mFormat; fastTrack->mGeneration++; state->mTrackMask |= 1 << j; didModify = true; // no acknowledgement required for newly active tracks } // cache the combined master volume and stream type volume for fast mixer; this // lacks any synchronization or barrier so VolumeProvider may read a stale value track->mCachedVolume = masterVolume * mStreamTypes[track->streamType()].volume; ++fastTracks; } else { // was it previously active? if (state->mTrackMask & (1 << j)) { fastTrack->mBufferProvider = NULL; fastTrack->mGeneration++; state->mTrackMask &= ~(1 << j); didModify = true; // If any fast tracks were removed, we must wait for acknowledgement // because we're about to decrement the last sp<> on those tracks. block = FastMixerStateQueue::BLOCK_UNTIL_ACKED; } else { LOG_ALWAYS_FATAL("fast track %d should have been active; " "mState=%d, mTrackMask=%#x, recentUnderruns=%u, isShared=%d", j, track->mState, state->mTrackMask, recentUnderruns, track->sharedBuffer() != 0); } tracksToRemove->add(track); // Avoids a misleading display in dumpsys track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL; } continue; } { // local variable scope to avoid goto warning audio_track_cblk_t* cblk = track->cblk(); // The first time a track is added we wait // for all its buffers to be filled before processing it int name = track->name(); // make sure that we have enough frames to mix one full buffer. // enforce this condition only once to enable draining the buffer in case the client // app does not call stop() and relies on underrun to stop: // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed // during last round size_t desiredFrames; const uint32_t sampleRate = track->mAudioTrackServerProxy->getSampleRate(); AudioPlaybackRate playbackRate = track->mAudioTrackServerProxy->getPlaybackRate(); desiredFrames = sourceFramesNeededWithTimestretch( sampleRate, mNormalFrameCount, mSampleRate, playbackRate.mSpeed); // TODO: ONLY USED FOR LEGACY RESAMPLERS, remove when they are removed. // add frames already consumed but not yet released by the resampler // because mAudioTrackServerProxy->framesReady() will include these frames desiredFrames += mAudioMixer->getUnreleasedFrames(track->name()); uint32_t minFrames = 1; if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() && (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY)) { minFrames = desiredFrames; } size_t framesReady = track->framesReady(); if (ATRACE_ENABLED()) { // I wish we had formatted trace names char traceName[16]; strcpy(traceName, "nRdy"); int name = track->name(); if (AudioMixer::TRACK0 <= name && name < (int) (AudioMixer::TRACK0 + AudioMixer::MAX_NUM_TRACKS)) { name -= AudioMixer::TRACK0; traceName[4] = (name / 10) + '0'; traceName[5] = (name % 10) + '0'; } else { traceName[4] = '?'; traceName[5] = '?'; } traceName[6] = '\0'; ATRACE_INT(traceName, framesReady); } if ((framesReady >= minFrames) && track->isReady() && !track->isPaused() && !track->isTerminated()) { ALOGVV("track %d s=%08x [OK] on thread %p", name, cblk->mServer, this); mixedTracks++; // track->mainBuffer() != mSinkBuffer or mMixerBuffer means // there is an effect chain connected to the track chain.clear(); if (track->mainBuffer() != mSinkBuffer && track->mainBuffer() != mMixerBuffer) { if (mEffectBufferEnabled) { mEffectBufferValid = true; // Later can set directly. } chain = getEffectChain_l(track->sessionId()); // Delegate volume control to effect in track effect chain if needed if (chain != 0) { tracksWithEffect++; } else { ALOGW("prepareTracks_l(): track %d attached to effect but no chain found on " "session %d", name, track->sessionId()); } } int param = AudioMixer::VOLUME; if (track->mFillingUpStatus == Track::FS_FILLED) { // no ramp for the first volume setting track->mFillingUpStatus = Track::FS_ACTIVE; if (track->mState == TrackBase::RESUMING) { track->mState = TrackBase::ACTIVE; param = AudioMixer::RAMP_VOLUME; } mAudioMixer->setParameter(name, AudioMixer::RESAMPLE, AudioMixer::RESET, NULL); // FIXME should not make a decision based on mServer } else if (cblk->mServer != 0) { // If the track is stopped before the first frame was mixed, // do not apply ramp param = AudioMixer::RAMP_VOLUME; } // compute volume for this track uint32_t vl, vr; // in U8.24 integer format float vlf, vrf, vaf; // in [0.0, 1.0] float format if (track->isPausing() || mStreamTypes[track->streamType()].mute) { vl = vr = 0; vlf = vrf = vaf = 0.; if (track->isPausing()) { track->setPaused(); } } else { // read original volumes with volume control float typeVolume = mStreamTypes[track->streamType()].volume; float v = masterVolume * typeVolume; //add for boot video:sync audio for boot char value[PROPERTY_VALUE_MAX] = ""; property_get("persist.sys.bootvideo.enable", value, "false"); if(!strcmp(value,"true")){ property_get("sys.bootvideo.closed", value, "1"); if (atoi(value) == 0){ ALOGV("bootvideo running now,audioflinger no need to control volume"); v = 1.0; } } AudioTrackServerProxy *proxy = track->mAudioTrackServerProxy; gain_minifloat_packed_t vlr = proxy->getVolumeLR(); vlf = float_from_gain(gain_minifloat_unpack_left(vlr)); vrf = float_from_gain(gain_minifloat_unpack_right(vlr)); // track volumes come from shared memory, so can't be trusted and must be clamped if (vlf > GAIN_FLOAT_UNITY) { ALOGV("Track left volume out of range: %.3g", vlf); vlf = GAIN_FLOAT_UNITY; } if (vrf > GAIN_FLOAT_UNITY) { ALOGV("Track right volume out of range: %.3g", vrf); vrf = GAIN_FLOAT_UNITY; } // now apply the master volume and stream type volume vlf *= v; vrf *= v; // assuming master volume and stream type volume each go up to 1.0, // then derive vl and vr as U8.24 versions for the effect chain const float scaleto8_24 = MAX_GAIN_INT * MAX_GAIN_INT; vl = (uint32_t) (scaleto8_24 * vlf); vr = (uint32_t) (scaleto8_24 * vrf); // vl and vr are now in U8.24 format uint16_t sendLevel = proxy->getSendLevel_U4_12(); // send level comes from shared memory and so may be corrupt if (sendLevel > MAX_GAIN_INT) { ALOGV("Track send level out of range: %04X", sendLevel); sendLevel = MAX_GAIN_INT; } // vaf is represented as [0.0, 1.0] float by rescaling sendLevel vaf = v * sendLevel * (1. / MAX_GAIN_INT); } // Delegate volume control to effect in track effect chain if needed if (chain != 0 && chain->setVolume_l(&vl, &vr)) { // Do not ramp volume if volume is controlled by effect param = AudioMixer::VOLUME; // Update remaining floating point volume levels vlf = (float)vl / (1 << 24); vrf = (float)vr / (1 << 24); track->mHasVolumeController = true; } else { // force no volume ramp when volume controller was just disabled or removed // from effect chain to avoid volume spike if (track->mHasVolumeController) { param = AudioMixer::VOLUME; } track->mHasVolumeController = false; } // XXX: these things DON'T need to be done each time mAudioMixer->setBufferProvider(name, track); mAudioMixer->enable(name); mAudioMixer->setParameter(name, param, AudioMixer::VOLUME0, &vlf); mAudioMixer->setParameter(name, param, AudioMixer::VOLUME1, &vrf); mAudioMixer->setParameter(name, param, AudioMixer::AUXLEVEL, &vaf); mAudioMixer->setParameter( name, AudioMixer::TRACK, AudioMixer::FORMAT, (void *)track->format()); mAudioMixer->setParameter( name, AudioMixer::TRACK, AudioMixer::CHANNEL_MASK, (void *)(uintptr_t)track->channelMask()); mAudioMixer->setParameter( name, AudioMixer::TRACK, AudioMixer::MIXER_CHANNEL_MASK, (void *)(uintptr_t)mChannelMask); // limit track sample rate to 2 x output sample rate, which changes at re-configuration uint32_t maxSampleRate = mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX; uint32_t reqSampleRate = track->mAudioTrackServerProxy->getSampleRate(); if (reqSampleRate == 0) { reqSampleRate = mSampleRate; } else if (reqSampleRate > maxSampleRate) { reqSampleRate = maxSampleRate; } mAudioMixer->setParameter( name, AudioMixer::RESAMPLE, AudioMixer::SAMPLE_RATE, (void *)(uintptr_t)reqSampleRate); AudioPlaybackRate playbackRate = track->mAudioTrackServerProxy->getPlaybackRate(); mAudioMixer->setParameter( name, AudioMixer::TIMESTRETCH, AudioMixer::PLAYBACK_RATE, &playbackRate); /* * Select the appropriate output buffer for the track. * * Tracks with effects go into their own effects chain buffer * and from there into either mEffectBuffer or mSinkBuffer. * * Other tracks can use mMixerBuffer for higher precision * channel accumulation. If this buffer is enabled * (mMixerBufferEnabled true), then selected tracks will accumulate * into it. * */ if (mMixerBufferEnabled && (track->mainBuffer() == mSinkBuffer || track->mainBuffer() == mMixerBuffer)) { mAudioMixer->setParameter( name, AudioMixer::TRACK, AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat); mAudioMixer->setParameter( name, AudioMixer::TRACK, AudioMixer::MAIN_BUFFER, (void *)mMixerBuffer); // TODO: override track->mainBuffer()? mMixerBufferValid = true; } else { mAudioMixer->setParameter( name, AudioMixer::TRACK, AudioMixer::MIXER_FORMAT, (void *)AUDIO_FORMAT_PCM_16_BIT); mAudioMixer->setParameter( name, AudioMixer::TRACK, AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer()); } mAudioMixer->setParameter( name, AudioMixer::TRACK, AudioMixer::AUX_BUFFER, (void *)track->auxBuffer()); // reset retry count track->mRetryCount = kMaxTrackRetries; // If one track is ready, set the mixer ready if: // - the mixer was not ready during previous round OR // - no other track is not ready if (mMixerStatusIgnoringFastTracks != MIXER_TRACKS_READY || mixerStatus != MIXER_TRACKS_ENABLED) { mixerStatus = MIXER_TRACKS_READY; } } else { if (framesReady < desiredFrames && !track->isStopped() && !track->isPaused()) { ALOGV("track(%p) underrun, framesReady(%zu) < framesDesired(%zd)", track, framesReady, desiredFrames); track->mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames); } else { track->mAudioTrackServerProxy->tallyUnderrunFrames(0); } // clear effect chain input buffer if an active track underruns to avoid sending // previous audio buffer again to effects chain = getEffectChain_l(track->sessionId()); if (chain != 0) { chain->clearInputBuffer(); } ALOGVV("track %d s=%08x [NOT READY] on thread %p", name, cblk->mServer, this); if ((track->sharedBuffer() != 0) || track->isTerminated() || track->isStopped() || track->isPaused()) { // We have consumed all the buffers of this track. // Remove it from the list of active tracks. // TODO: use actual buffer filling status instead of latency when available from // audio HAL size_t audioHALFrames = (latency_l() * mSampleRate) / 1000; int64_t framesWritten = mBytesWritten / mFrameSize; if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) { if (track->isStopped()) { track->reset(); } tracksToRemove->add(track); } } else { // No buffers for this track. Give it a few chances to // fill a buffer, then remove it from active list. if (--(track->mRetryCount) <= 0) { ALOGI("BUFFER TIMEOUT: remove(%d) from active list on thread %p", name, this); tracksToRemove->add(track); // indicate to client process that the track was disabled because of underrun; // it will then automatically call start() when data is available track->disable(); // If one track is not ready, mark the mixer also not ready if: // - the mixer was ready during previous round OR // - no other track is ready } else if (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY || mixerStatus != MIXER_TRACKS_READY) { mixerStatus = MIXER_TRACKS_ENABLED; } } mAudioMixer->disable(name); } } // local variable scope to avoid goto warning } // Push the new FastMixer state if necessary bool pauseAudioWatchdog = false; if (didModify) { state->mFastTracksGen++; // if the fast mixer was active, but now there are no fast tracks, then put it in cold idle if (kUseFastMixer == FastMixer_Dynamic && state->mCommand == FastMixerState::MIX_WRITE && state->mTrackMask <= 1) { state->mCommand = FastMixerState::COLD_IDLE; state->mColdFutexAddr = &mFastMixerFutex; state->mColdGen++; mFastMixerFutex = 0; if (kUseFastMixer == FastMixer_Dynamic) { mNormalSink = mOutputSink; } // If we go into cold idle, need to wait for acknowledgement // so that fast mixer stops doing I/O. block = FastMixerStateQueue::BLOCK_UNTIL_ACKED; pauseAudioWatchdog = true; } } if (sq != NULL) { sq->end(didModify); sq->push(block); } #ifdef AUDIO_WATCHDOG if (pauseAudioWatchdog && mAudioWatchdog != 0) { mAudioWatchdog->pause(); } #endif // Now perform the deferred reset on fast tracks that have stopped while (resetMask != 0) { size_t i = __builtin_ctz(resetMask); ALOG_ASSERT(i < count); resetMask &= ~(1 << i); sp<Track> t = mActiveTracks[i].promote(); if (t == 0) { continue; } Track* track = t.get(); ALOG_ASSERT(track->isFastTrack() && track->isStopped()); track->reset(); } // remove all the tracks that need to be... removeTracks_l(*tracksToRemove); if (getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX) != 0) { mEffectBufferValid = true; } if (mEffectBufferValid) { // as long as there are effects we should clear the effects buffer, to avoid // passing a non-clean buffer to the effect chain memset(mEffectBuffer, 0, mEffectBufferSize); } // sink or mix buffer must be cleared if all tracks are connected to an // effect chain as in this case the mixer will not write to the sink or mix buffer // and track effects will accumulate into it if ((mBytesRemaining == 0) && ((mixedTracks != 0 && mixedTracks == tracksWithEffect) || (mixedTracks == 0 && fastTracks > 0))) { // FIXME as a performance optimization, should remember previous zero status if (mMixerBufferValid) { memset(mMixerBuffer, 0, mMixerBufferSize); // TODO: In testing, mSinkBuffer below need not be cleared because // the PlaybackThread::threadLoop() copies mMixerBuffer into mSinkBuffer // after mixing. // // To enforce this guarantee: // ((mixedTracks != 0 && mixedTracks == tracksWithEffect) || // (mixedTracks == 0 && fastTracks > 0)) // must imply MIXER_TRACKS_READY. // Later, we may clear buffers regardless, and skip much of this logic. } // FIXME as a performance optimization, should remember previous zero status memset(mSinkBuffer, 0, mNormalFrameCount * mFrameSize); } // if any fast tracks, then status is ready mMixerStatusIgnoringFastTracks = mixerStatus; if (fastTracks > 0) { mixerStatus = MIXER_TRACKS_READY; } return mixerStatus; } 根据上下文优化这段代码
最新发布
08-14
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值